Add bind_over_mf2_test.cpp

Expand bind_over_mf_test.cpp
Add bind_over_mf_test.cpp
2024-01-04 20:56:32 +02:00 · 2024-01-04 20:49:06 +02:00 · 2024-01-04 20:36:39 +02:00 · 2024-01-04 20:26:54 +02:00 · 2024-01-02 20:09:20 +02:00 · 2024-01-02 19:55:36 +02:00
29 changed files with 1462 additions and 647 deletions
--- a/.drone.jsonnet
+++ b/.drone.jsonnet
@@ -0,0 +1,338 @@
+# Copyright 2022 Peter Dimov
+# Distributed under the Boost Software License, Version 1.0.
+# https://www.boost.org/LICENSE_1_0.txt
+
+local library = "bind";
+
+local triggers =
+{
+    branch: [ "master", "develop", "feature/*" ]
+};
+
+local ubsan = { UBSAN: '1', UBSAN_OPTIONS: 'print_stacktrace=1' };
+local asan = { ASAN: '1' };
+
+local linux_pipeline(name, image, environment, packages = "", sources = [], arch = "amd64") =
+{
+    name: name,
+    kind: "pipeline",
+    type: "docker",
+    trigger: triggers,
+    platform:
+    {
+        os: "linux",
+        arch: arch
+    },
+    steps:
+    [
+        {
+            name: "everything",
+            image: image,
+            environment: environment,
+            commands:
+            [
+                'set -e',
+                'wget -O - https://apt.llvm.org/llvm-snapshot.gpg.key | apt-key add -',
+            ] +
+            (if sources != [] then [ ('apt-add-repository "' + source + '"') for source in sources ] else []) +
+            (if packages != "" then [ 'apt-get update', 'apt-get -y install ' + packages ] else []) +
+            [
+                'export LIBRARY=' + library,
+                './.drone/drone.sh',
+            ]
+        }
+    ]
+};
+
+local macos_pipeline(name, environment, xcode_version = "12.2", osx_version = "catalina", arch = "amd64") =
+{
+    name: name,
+    kind: "pipeline",
+    type: "exec",
+    trigger: triggers,
+    platform: {
+        "os": "darwin",
+        "arch": arch
+    },
+    node: {
+        "os": osx_version
+    },
+    steps: [
+        {
+            name: "everything",
+            environment: environment + { "DEVELOPER_DIR": "/Applications/Xcode-" + xcode_version + ".app/Contents/Developer" },
+            commands:
+            [
+                'export LIBRARY=' + library,
+                './.drone/drone.sh',
+            ]
+        }
+    ]
+};
+
+local windows_pipeline(name, image, environment, arch = "amd64") =
+{
+    name: name,
+    kind: "pipeline",
+    type: "docker",
+    trigger: triggers,
+    platform:
+    {
+        os: "windows",
+        arch: arch
+    },
+    "steps":
+    [
+        {
+            name: "everything",
+            image: image,
+            environment: environment,
+            commands:
+            [
+                'cmd /C .drone\\\\drone.bat ' + library,
+            ]
+        }
+    ]
+};
+
+[
+    linux_pipeline(
+        "Linux 16.04 GCC 4.4",
+        "cppalliance/droneubuntu1604:1",
+        { TOOLSET: 'gcc', COMPILER: 'g++-4.4', CXXSTD: '98,0x' },
+        "g++-4.4",
+        [ "ppa:ubuntu-toolchain-r/test" ],
+    ),
+
+    linux_pipeline(
+        "Linux 16.04 GCC 4.6",
+        "cppalliance/droneubuntu1604:1",
+        { TOOLSET: 'gcc', COMPILER: 'g++-4.6', CXXSTD: '98,0x' },
+        "g++-4.6",
+        [ "ppa:ubuntu-toolchain-r/test" ],
+    ),
+
+    linux_pipeline(
+        "Linux 16.04 GCC 4.7",
+        "cppalliance/droneubuntu1604:1",
+        { TOOLSET: 'gcc', COMPILER: 'g++-4.7', CXXSTD: '98,0x' },
+        "g++-4.7",
+    ),
+
+    linux_pipeline(
+        "Linux 16.04 GCC 4.8",
+        "cppalliance/droneubuntu1604:1",
+        { TOOLSET: 'gcc', COMPILER: 'g++-4.8', CXXSTD: '03,11' },
+        "g++-4.8",
+    ),
+
+    linux_pipeline(
+        "Linux 16.04 GCC 4.9",
+        "cppalliance/droneubuntu1604:1",
+        { TOOLSET: 'gcc', COMPILER: 'g++-4.9', CXXSTD: '03,11' },
+        "g++-4.9",
+    ),
+
+    linux_pipeline(
+        "Linux 16.04 GCC 5*",
+        "cppalliance/droneubuntu1604:1",
+        { TOOLSET: 'gcc', COMPILER: 'g++', CXXSTD: '03,11,14' },
+    ),
+
+    linux_pipeline(
+        "Linux 18.04 GCC 6",
+        "cppalliance/droneubuntu1804:1",
+        { TOOLSET: 'gcc', COMPILER: 'g++-6', CXXSTD: '03,11,14' },
+        "g++-6",
+    ),
+
+    linux_pipeline(
+        "Linux 18.04 GCC 7* 32/64",
+        "cppalliance/droneubuntu1804:1",
+        { TOOLSET: 'gcc', COMPILER: 'g++', CXXSTD: '03,11,14,17', ADDRMD: '32,64' },
+    ),
+
+    linux_pipeline(
+        "Linux 18.04 GCC 8",
+        "cppalliance/droneubuntu1804:1",
+        { TOOLSET: 'gcc', COMPILER: 'g++-8', CXXSTD: '03,11,14,17' },
+        "g++-8",
+    ),
+
+    linux_pipeline(
+        "Linux 20.04 GCC 9* 32/64",
+        "cppalliance/droneubuntu2004:1",
+        { TOOLSET: 'gcc', COMPILER: 'g++', CXXSTD: '03,11,14,17,2a', ADDRMD: '32,64' },
+    ),
+
+    linux_pipeline(
+        "Linux 20.04 GCC 9* ARM64",
+        "cppalliance/droneubuntu2004:multiarch",
+        { TOOLSET: 'gcc', COMPILER: 'g++', CXXSTD: '03,11,14,17,2a' },
+        arch="arm64",
+    ),
+
+    linux_pipeline(
+        "Linux 20.04 GCC 9* S390x",
+        "cppalliance/droneubuntu2004:multiarch",
+        { TOOLSET: 'gcc', COMPILER: 'g++', CXXSTD: '03,11,14,17,2a' },
+        arch="s390x",
+    ),
+
+    linux_pipeline(
+        "Linux 20.04 GCC 10 32/64",
+        "cppalliance/droneubuntu2004:1",
+        { TOOLSET: 'gcc', COMPILER: 'g++-10', CXXSTD: '03,11,14,17,20', ADDRMD: '32,64' },
+        "g++-10-multilib",
+    ),
+
+    linux_pipeline(
+        "Linux 22.04 GCC 11* 32/64",
+        "cppalliance/droneubuntu2204:1",
+        { TOOLSET: 'gcc', COMPILER: 'g++', CXXSTD: '03,11,14,17,2a', ADDRMD: '32,64' },
+    ),
+
+    linux_pipeline(
+        "Linux 22.04 GCC 12 32 ASAN",
+        "cppalliance/droneubuntu2204:1",
+        { TOOLSET: 'gcc', COMPILER: 'g++-12', CXXSTD: '03,11,14,17,20,2b', ADDRMD: '32' } + asan,
+        "g++-12-multilib",
+    ),
+
+    linux_pipeline(
+        "Linux 22.04 GCC 12 64 ASAN",
+        "cppalliance/droneubuntu2204:1",
+        { TOOLSET: 'gcc', COMPILER: 'g++-12', CXXSTD: '03,11,14,17,20,2b', ADDRMD: '64' } + asan,
+        "g++-12-multilib",
+    ),
+
+    linux_pipeline(
+        "Linux 23.04 GCC 13 32 UBSAN",
+        "cppalliance/droneubuntu2304:1",
+        { TOOLSET: 'gcc', COMPILER: 'g++-13', CXXSTD: '03,11,14,17,20,2b', ADDRMD: '32' } + ubsan,
+        "g++-13-multilib",
+    ),
+
+    linux_pipeline(
+        "Linux 23.04 GCC 13 64 UBSAN",
+        "cppalliance/droneubuntu2304:1",
+        { TOOLSET: 'gcc', COMPILER: 'g++-13', CXXSTD: '03,11,14,17,20,2b', ADDRMD: '64' } + ubsan,
+        "g++-13-multilib",
+    ),
+
+    linux_pipeline(
+        "Linux 16.04 Clang 3.5",
+        "cppalliance/droneubuntu1604:1",
+        { TOOLSET: 'clang', COMPILER: 'clang++-3.5', CXXSTD: '03,11,14' },
+        "clang-3.5",
+    ),
+
+    linux_pipeline(
+        "Linux 16.04 Clang 3.6",
+        "cppalliance/droneubuntu1604:1",
+        { TOOLSET: 'clang', COMPILER: 'clang++-3.6', CXXSTD: '03,11,14' },
+        "clang-3.6",
+    ),
+
+    linux_pipeline(
+        "Linux 16.04 Clang 3.7",
+        "cppalliance/droneubuntu1604:1",
+        { TOOLSET: 'clang', COMPILER: 'clang++-3.7', CXXSTD: '03,11,14' },
+        "clang-3.7",
+    ),
+
+    linux_pipeline(
+        "Linux 16.04 Clang 3.8",
+        "cppalliance/droneubuntu1604:1",
+        { TOOLSET: 'clang', COMPILER: 'clang++-3.8', CXXSTD: '03,11,14' },
+        "clang-3.8",
+    ),
+
+    linux_pipeline(
+        "Linux 22.04 Clang 13",
+        "cppalliance/droneubuntu2204:1",
+        { TOOLSET: 'clang', COMPILER: 'clang++-13', CXXSTD: '03,11,14,17,20,2b' },
+        "clang-13",
+    ),
+
+    linux_pipeline(
+        "Linux 22.04 Clang 14",
+        "cppalliance/droneubuntu2204:1",
+        { TOOLSET: 'clang', COMPILER: 'clang++-14', CXXSTD: '03,11,14,17,20,2b' },
+        "clang-14",
+    ),
+
+    linux_pipeline(
+        "Linux 22.04 Clang 15",
+        "cppalliance/droneubuntu2204:1",
+        { TOOLSET: 'clang', COMPILER: 'clang++-15', CXXSTD: '03,11,14,17,20,2b' },
+        "clang-15",
+    ),
+
+    linux_pipeline(
+        "Linux 23.04 Clang 16",
+        "cppalliance/droneubuntu2304:1",
+        { TOOLSET: 'clang', COMPILER: 'clang++-16', CXXSTD: '11,14,17,20,2b' },
+        "clang-16",
+    ),
+
+    linux_pipeline(
+        "Linux 23.10 Clang 17 UBSAN",
+        "cppalliance/droneubuntu2310:1",
+        { TOOLSET: 'clang', COMPILER: 'clang++-17', CXXSTD: '11,14,17,20,2b' } + ubsan,
+        "clang-17",
+    ),
+
+    linux_pipeline(
+        "Linux 23.10 Clang 17 ASAN",
+        "cppalliance/droneubuntu2310:1",
+        { TOOLSET: 'clang', COMPILER: 'clang++-17', CXXSTD: '11,14,17,20,2b' } + asan,
+        "clang-17",
+    ),
+
+    macos_pipeline(
+        "MacOS 10.15 Xcode 12.2 UBSAN",
+        { TOOLSET: 'clang', COMPILER: 'clang++', CXXSTD: '03,11,14,1z' } + ubsan,
+    ),
+
+    macos_pipeline(
+        "MacOS 10.15 Xcode 12.2 ASAN",
+        { TOOLSET: 'clang', COMPILER: 'clang++', CXXSTD: '03,11,14,1z' } + asan,
+    ),
+
+    macos_pipeline(
+        "MacOS 12.4 Xcode 13.4.1 UBSAN",
+        { TOOLSET: 'clang', COMPILER: 'clang++', CXXSTD: '03,11,14,17,20,2b' } + ubsan,
+        xcode_version = "13.4.1", osx_version = "monterey", arch = "arm64",
+    ),
+
+    macos_pipeline(
+        "MacOS 12.4 Xcode 13.4.1 ASAN",
+        { TOOLSET: 'clang', COMPILER: 'clang++', CXXSTD: '03,11,14,17,20,2b' } + asan,
+        xcode_version = "13.4.1", osx_version = "monterey", arch = "arm64",
+    ),
+
+    windows_pipeline(
+        "Windows VS2015 msvc-14.0",
+        "cppalliance/dronevs2015",
+        { TOOLSET: 'msvc-14.0', CXXSTD: '14,latest', B2_DONT_EMBED_MANIFEST: '1' },
+    ),
+
+    windows_pipeline(
+        "Windows VS2017 msvc-14.1",
+        "cppalliance/dronevs2017",
+        { TOOLSET: 'msvc-14.1', CXXSTD: '14,17,latest' },
+    ),
+
+    windows_pipeline(
+        "Windows VS2019 msvc-14.2",
+        "cppalliance/dronevs2019",
+        { TOOLSET: 'msvc-14.2', CXXSTD: '14,17,20,latest' },
+    ),
+
+    windows_pipeline(
+        "Windows VS2022 msvc-14.3",
+        "cppalliance/dronevs2022:1",
+        { TOOLSET: 'msvc-14.3', CXXSTD: '14,17,20,latest' },
+    ),
+]
--- a/.drone/drone.bat
+++ b/.drone/drone.bat
@@ -0,0 +1,23 @@
+@REM Copyright 2022 Peter Dimov
+@REM Distributed under the Boost Software License, Version 1.0.
+@REM https://www.boost.org/LICENSE_1_0.txt
+
+@ECHO ON
+
+set LIBRARY=%1
+set DRONE_BUILD_DIR=%CD%
+
+set BOOST_BRANCH=develop
+if "%DRONE_BRANCH%" == "master" set BOOST_BRANCH=master
+cd ..
+git clone -b %BOOST_BRANCH% --depth 1 https://github.com/boostorg/boost.git boost-root
+cd boost-root
+git submodule update --init tools/boostdep
+xcopy /s /e /q %DRONE_BUILD_DIR% libs\%LIBRARY%\
+python tools/boostdep/depinst/depinst.py %LIBRARY%
+cmd /c bootstrap
+b2 -d0 headers
+
+if not "%CXXSTD%" == "" set CXXSTD=cxxstd=%CXXSTD%
+if not "%ADDRMD%" == "" set ADDRMD=address-model=%ADDRMD%
+b2 -j3 libs/%LIBRARY%/test toolset=%TOOLSET% %CXXSTD% %ADDRMD% variant=debug,release embed-manifest-via=linker
--- a/.drone/drone.sh
+++ b/.drone/drone.sh
@@ -0,0 +1,25 @@
+#!/bin/bash
+
+# Copyright 2022 Peter Dimov
+# Distributed under the Boost Software License, Version 1.0.
+# https://www.boost.org/LICENSE_1_0.txt
+
+set -ex
+export PATH=~/.local/bin:/usr/local/bin:$PATH
+
+DRONE_BUILD_DIR=$(pwd)
+
+BOOST_BRANCH=develop
+if [ "$DRONE_BRANCH" = "master" ]; then BOOST_BRANCH=master; fi
+
+cd ..
+git clone -b $BOOST_BRANCH --depth 1 https://github.com/boostorg/boost.git boost-root
+cd boost-root
+git submodule update --init tools/boostdep
+cp -r $DRONE_BUILD_DIR/* libs/$LIBRARY
+python tools/boostdep/depinst/depinst.py $LIBRARY
+./bootstrap.sh
+./b2 -d0 headers
+
+echo "using $TOOLSET : : $COMPILER ;" > ~/user-config.jam
+./b2 -j3 libs/$LIBRARY/test toolset=$TOOLSET cxxstd=$CXXSTD variant=debug,release ${ADDRMD:+address-model=$ADDRMD} ${UBSAN:+undefined-sanitizer=norecover debug-symbols=on} ${ASAN:+address-sanitizer=norecover debug-symbols=on} ${LINKFLAGS:+linkflags=$LINKFLAGS}
--- a/.github/workflows/ci.yml
+++ b/.github/workflows/ci.yml
@@ -17,112 +17,163 @@ jobs:
      fail-fast: false
      matrix:
        include:
-          - toolset: gcc-4.7
-            cxxstd: "03,11"
-            os: ubuntu-16.04
-            install: g++-4.7
          - toolset: gcc-4.8
            cxxstd: "03,11"
-            os: ubuntu-16.04
+            container: ubuntu:18.04
+            os: ubuntu-latest
            install: g++-4.8
-          - toolset: gcc-4.9
-            cxxstd: "03,11"
-            os: ubuntu-16.04
-            install: g++-4.9
          - toolset: gcc-5
            cxxstd: "03,11,14,1z"
-            os: ubuntu-16.04
+            container: ubuntu:18.04
+            os: ubuntu-latest
+            install: g++-5
          - toolset: gcc-6
            cxxstd: "03,11,14,1z"
-            os: ubuntu-16.04
+            container: ubuntu:18.04
+            os: ubuntu-latest
            install: g++-6
          - toolset: gcc-7
            cxxstd: "03,11,14,17"
-            os: ubuntu-18.04
+            os: ubuntu-20.04
+            install: g++-7
          - toolset: gcc-8
            cxxstd: "03,11,14,17,2a"
-            os: ubuntu-18.04
+            os: ubuntu-20.04
            install: g++-8
          - toolset: gcc-9
            cxxstd: "03,11,14,17,2a"
-            os: ubuntu-18.04
+            os: ubuntu-20.04
          - toolset: gcc-10
            cxxstd: "03,11,14,17,2a"
-            os: ubuntu-18.04
-          - toolset: clang
-            compiler: clang++-3.5
-            cxxstd: "03,11,14"
-            os: ubuntu-16.04
-            install: clang-3.5
-          - toolset: clang
-            compiler: clang++-3.6
-            cxxstd: "03,11,14"
-            os: ubuntu-16.04
-            install: clang-3.6
-          - toolset: clang
-            compiler: clang++-3.7
-            cxxstd: "03,11,14"
-            os: ubuntu-16.04
-            install: clang-3.7
-          - toolset: clang
-            compiler: clang++-3.8
-            cxxstd: "03,11,14"
-            os: ubuntu-16.04
-            install: clang-3.8
+            os: ubuntu-20.04
+            install: g++-10
+          - toolset: gcc-11
+            cxxstd: "03,11,14,17,2a"
+            os: ubuntu-20.04
+            install: g++-11
+          - toolset: gcc-12
+            cxxstd: "03,11,14,17,20,2b"
+            os: ubuntu-22.04
+            install: g++-12
+          - toolset: gcc-13
+            cxxstd: "03,11,14,17,20,2b"
+            container: ubuntu:23.04
+            os: ubuntu-latest
+            install: g++-13
          - toolset: clang
            compiler: clang++-3.9
            cxxstd: "03,11,14"
-            os: ubuntu-16.04
+            container: ubuntu:18.04
+            os: ubuntu-latest
            install: clang-3.9
          - toolset: clang
            compiler: clang++-4.0
            cxxstd: "03,11,14"
-            os: ubuntu-16.04
+            container: ubuntu:18.04
+            os: ubuntu-latest
            install: clang-4.0
          - toolset: clang
            compiler: clang++-5.0
            cxxstd: "03,11,14,1z"
-            os: ubuntu-16.04
+            container: ubuntu:18.04
+            os: ubuntu-latest
            install: clang-5.0
          - toolset: clang
            compiler: clang++-6.0
            cxxstd: "03,11,14,17"
-            os: ubuntu-18.04
+            os: ubuntu-20.04
            install: clang-6.0
          - toolset: clang
            compiler: clang++-7
            cxxstd: "03,11,14,17"
-            os: ubuntu-18.04
+            os: ubuntu-20.04
            install: clang-7
          - toolset: clang
            compiler: clang++-8
-            cxxstd: "03,11,14,17,2a"
+            cxxstd: "03,11,14,17"
            os: ubuntu-20.04
            install: clang-8
          - toolset: clang
            compiler: clang++-9
            cxxstd: "03,11,14,17,2a"
            os: ubuntu-20.04
+            install: clang-9
          - toolset: clang
            compiler: clang++-10
            cxxstd: "03,11,14,17,2a"
            os: ubuntu-20.04
+            install: clang-10
          - toolset: clang
            compiler: clang++-11
            cxxstd: "03,11,14,17,2a"
            os: ubuntu-20.04
+            install: clang-11
+          - toolset: clang
+            compiler: clang++-12
+            cxxstd: "03,11,14,17,2a"
+            os: ubuntu-20.04
+            install: clang-12
+          - toolset: clang
+            compiler: clang++-13
+            cxxstd: "03,11,14,17,20,2b"
+            container: ubuntu:22.04
+            os: ubuntu-latest
+            install: clang-13
+          - toolset: clang
+            compiler: clang++-14
+            cxxstd: "03,11,14,17,20,2b"
+            container: ubuntu:22.04
+            os: ubuntu-latest
+            install: clang-14
+          - toolset: clang
+            compiler: clang++-15
+            cxxstd: "03,11,14,17,20,2b"
+            container: ubuntu:22.04
+            os: ubuntu-latest
+            install: clang-15
+          - toolset: clang
+            compiler: clang++-16
+            cxxstd: "03,11,14,17,20,2b"
+            container: ubuntu:23.04
+            os: ubuntu-latest
+            install: clang-16
+          - toolset: clang
+            compiler: clang++-17
+            cxxstd: "03,11,14,17,20,2b"
+            container: ubuntu:23.10
+            os: ubuntu-latest
+            install: clang-17
          - toolset: clang
            cxxstd: "03,11,14,17,2a"
-            os: macos-10.15
+            os: macos-11
+          - toolset: clang
+            cxxstd: "03,11,14,17,20,2b"
+            os: macos-12
+          - toolset: clang
+            cxxstd: "03,11,14,17,20,2b"
+            os: macos-13

    runs-on: ${{matrix.os}}
+    container: ${{matrix.container}}
+
+    defaults:
+      run:
+        shell: bash

    steps:
-      - uses: actions/checkout@v2
+      - uses: actions/checkout@v3
+
+      - name: Setup container environment
+        if: matrix.container
+        run: |
+          apt-get update
+          apt-get -y install sudo python3 git g++

      - name: Install packages
        if: matrix.install
-        run: sudo apt install ${{matrix.install}}
+        run: |
+          sudo apt-get update
+          sudo apt-get -y install ${{matrix.install}}

      - name: Setup Boost
        run: |
@@ -142,7 +193,7 @@ jobs:
          cd boost-root
          cp -r $GITHUB_WORKSPACE/* libs/$LIBRARY
          git submodule update --init tools/boostdep
-          python tools/boostdep/depinst/depinst.py --git_args "--jobs 3" $LIBRARY
+          python3 tools/boostdep/depinst/depinst.py --git_args "--jobs 3" $LIBRARY
          ./bootstrap.sh
          ./b2 -d0 headers

@@ -161,14 +212,22 @@ jobs:
      fail-fast: false
      matrix:
        include:
-          - toolset: msvc-14.1
-            cxxstd: "14,17,latest"
-            addrmd: 32,64
-            os: windows-2016
-          - toolset: msvc-14.2
-            cxxstd: "14,17,latest"
+          - toolset: msvc-14.0
+            cxxstd: "14,latest"
            addrmd: 32,64
            os: windows-2019
+          - toolset: msvc-14.2
+            cxxstd: "14,17,20,latest"
+            addrmd: 32,64
+            os: windows-2019
+          - toolset: msvc-14.3
+            cxxstd: "14,17,20,latest"
+            addrmd: 32,64
+            os: windows-2022
+          - toolset: clang-win
+            cxxstd: "14,17,20,latest"
+            addrmd: 32,64
+            os: windows-2022
          - toolset: gcc
            cxxstd: "03,11,14,17,2a"
            addrmd: 64
@@ -177,7 +236,7 @@ jobs:
    runs-on: ${{matrix.os}}

    steps:
-      - uses: actions/checkout@v2
+      - uses: actions/checkout@v3

      - name: Setup Boost
        shell: cmd
@@ -205,4 +264,346 @@ jobs:
        shell: cmd
        run: |
          cd ../boost-root
-          b2 -j3 libs/%LIBRARY%/test toolset=${{matrix.toolset}} cxxstd=${{matrix.cxxstd}} address-model=${{matrix.addrmd}} variant=debug,release
+          b2 -j3 libs/%LIBRARY%/test toolset=${{matrix.toolset}} cxxstd=${{matrix.cxxstd}} address-model=${{matrix.addrmd}} variant=debug,release embed-manifest-via=linker
+
+  posix-cmake-subdir:
+    strategy:
+      fail-fast: false
+      matrix:
+        include:
+          - os: ubuntu-20.04
+          - os: ubuntu-22.04
+          - os: macos-11
+          - os: macos-12
+          - os: macos-13
+
+    runs-on: ${{matrix.os}}
+
+    steps:
+      - uses: actions/checkout@v3
+
+      - name: Install packages
+        if: matrix.install
+        run: sudo apt-get -y install ${{matrix.install}}
+
+      - name: Setup Boost
+        run: |
+          echo GITHUB_REPOSITORY: $GITHUB_REPOSITORY
+          LIBRARY=${GITHUB_REPOSITORY#*/}
+          echo LIBRARY: $LIBRARY
+          echo "LIBRARY=$LIBRARY" >> $GITHUB_ENV
+          echo GITHUB_BASE_REF: $GITHUB_BASE_REF
+          echo GITHUB_REF: $GITHUB_REF
+          REF=${GITHUB_BASE_REF:-$GITHUB_REF}
+          REF=${REF#refs/heads/}
+          echo REF: $REF
+          BOOST_BRANCH=develop && [ "$REF" == "master" ] && BOOST_BRANCH=master || true
+          echo BOOST_BRANCH: $BOOST_BRANCH
+          cd ..
+          git clone -b $BOOST_BRANCH --depth 1 https://github.com/boostorg/boost.git boost-root
+          cd boost-root
+          cp -r $GITHUB_WORKSPACE/* libs/$LIBRARY
+          git submodule update --init tools/boostdep
+          python tools/boostdep/depinst/depinst.py --git_args "--jobs 3" $LIBRARY
+
+      - name: Use library with add_subdirectory
+        run: |
+          cd ../boost-root/libs/$LIBRARY/test/cmake_subdir_test
+          mkdir __build__ && cd __build__
+          cmake ..
+          cmake --build .
+          ctest --output-on-failure --no-tests=error
+
+  posix-cmake-install:
+    strategy:
+      fail-fast: false
+      matrix:
+        include:
+          - os: ubuntu-20.04
+          - os: ubuntu-22.04
+          - os: macos-11
+          - os: macos-12
+          - os: macos-13
+
+    runs-on: ${{matrix.os}}
+
+    steps:
+      - uses: actions/checkout@v3
+
+      - name: Install packages
+        if: matrix.install
+        run: sudo apt-get -y install ${{matrix.install}}
+
+      - name: Setup Boost
+        run: |
+          echo GITHUB_REPOSITORY: $GITHUB_REPOSITORY
+          LIBRARY=${GITHUB_REPOSITORY#*/}
+          echo LIBRARY: $LIBRARY
+          echo "LIBRARY=$LIBRARY" >> $GITHUB_ENV
+          echo GITHUB_BASE_REF: $GITHUB_BASE_REF
+          echo GITHUB_REF: $GITHUB_REF
+          REF=${GITHUB_BASE_REF:-$GITHUB_REF}
+          REF=${REF#refs/heads/}
+          echo REF: $REF
+          BOOST_BRANCH=develop && [ "$REF" == "master" ] && BOOST_BRANCH=master || true
+          echo BOOST_BRANCH: $BOOST_BRANCH
+          cd ..
+          git clone -b $BOOST_BRANCH --depth 1 https://github.com/boostorg/boost.git boost-root
+          cd boost-root
+          cp -r $GITHUB_WORKSPACE/* libs/$LIBRARY
+          git submodule update --init tools/boostdep
+          python tools/boostdep/depinst/depinst.py --git_args "--jobs 3" $LIBRARY
+
+      - name: Configure
+        run: |
+          cd ../boost-root
+          mkdir __build__ && cd __build__
+          cmake -DBOOST_INCLUDE_LIBRARIES=$LIBRARY -DCMAKE_INSTALL_PREFIX=~/.local ..
+
+      - name: Install
+        run: |
+          cd ../boost-root/__build__
+          cmake --build . --target install
+
+      - name: Use the installed library
+        run: |
+          cd ../boost-root/libs/$LIBRARY/test/cmake_install_test && mkdir __build__ && cd __build__
+          cmake -DCMAKE_INSTALL_PREFIX=~/.local ..
+          cmake --build .
+          ctest --output-on-failure --no-tests=error
+
+  posix-cmake-test:
+    strategy:
+      fail-fast: false
+      matrix:
+        include:
+          - os: ubuntu-20.04
+          - os: ubuntu-22.04
+          - os: macos-11
+          - os: macos-12
+          - os: macos-13
+
+    runs-on: ${{matrix.os}}
+
+    steps:
+      - uses: actions/checkout@v3
+
+      - name: Install packages
+        if: matrix.install
+        run: sudo apt-get -y install ${{matrix.install}}
+
+      - name: Setup Boost
+        run: |
+          echo GITHUB_REPOSITORY: $GITHUB_REPOSITORY
+          LIBRARY=${GITHUB_REPOSITORY#*/}
+          echo LIBRARY: $LIBRARY
+          echo "LIBRARY=$LIBRARY" >> $GITHUB_ENV
+          echo GITHUB_BASE_REF: $GITHUB_BASE_REF
+          echo GITHUB_REF: $GITHUB_REF
+          REF=${GITHUB_BASE_REF:-$GITHUB_REF}
+          REF=${REF#refs/heads/}
+          echo REF: $REF
+          BOOST_BRANCH=develop && [ "$REF" == "master" ] && BOOST_BRANCH=master || true
+          echo BOOST_BRANCH: $BOOST_BRANCH
+          cd ..
+          git clone -b $BOOST_BRANCH --depth 1 https://github.com/boostorg/boost.git boost-root
+          cd boost-root
+          cp -r $GITHUB_WORKSPACE/* libs/$LIBRARY
+          git submodule update --init tools/boostdep
+          python tools/boostdep/depinst/depinst.py --git_args "--jobs 3" $LIBRARY
+
+      - name: Configure
+        run: |
+          cd ../boost-root
+          mkdir __build__ && cd __build__
+          cmake -DBOOST_INCLUDE_LIBRARIES=$LIBRARY -DBUILD_TESTING=ON ..
+
+      - name: Build tests
+        run: |
+          cd ../boost-root/__build__
+          cmake --build . --target tests
+
+      - name: Run tests
+        run: |
+          cd ../boost-root/__build__
+          ctest --output-on-failure --no-tests=error
+
+  windows-cmake-subdir:
+    strategy:
+      fail-fast: false
+      matrix:
+        include:
+          - os: windows-2019
+          - os: windows-2022
+
+    runs-on: ${{matrix.os}}
+
+    steps:
+      - uses: actions/checkout@v3
+
+      - name: Setup Boost
+        shell: cmd
+        run: |
+          echo GITHUB_REPOSITORY: %GITHUB_REPOSITORY%
+          for /f %%i in ("%GITHUB_REPOSITORY%") do set LIBRARY=%%~nxi
+          echo LIBRARY: %LIBRARY%
+          echo LIBRARY=%LIBRARY%>>%GITHUB_ENV%
+          echo GITHUB_BASE_REF: %GITHUB_BASE_REF%
+          echo GITHUB_REF: %GITHUB_REF%
+          if "%GITHUB_BASE_REF%" == "" set GITHUB_BASE_REF=%GITHUB_REF%
+          set BOOST_BRANCH=develop
+          for /f %%i in ("%GITHUB_BASE_REF%") do if "%%~nxi" == "master" set BOOST_BRANCH=master
+          echo BOOST_BRANCH: %BOOST_BRANCH%
+          cd ..
+          git clone -b %BOOST_BRANCH% --depth 1 https://github.com/boostorg/boost.git boost-root
+          cd boost-root
+          xcopy /s /e /q %GITHUB_WORKSPACE% libs\%LIBRARY%\
+          git submodule update --init tools/boostdep
+          python tools/boostdep/depinst/depinst.py --git_args "--jobs 3" %LIBRARY%
+
+      - name: Use library with add_subdirectory (Debug)
+        shell: cmd
+        run: |
+          cd ../boost-root/libs/%LIBRARY%/test/cmake_subdir_test
+          mkdir __build__ && cd __build__
+          cmake ..
+          cmake --build . --config Debug
+          ctest --output-on-failure --no-tests=error -C Debug
+
+      - name: Use library with add_subdirectory (Release)
+        shell: cmd
+        run: |
+          cd ../boost-root/libs/%LIBRARY%/test/cmake_subdir_test/__build__
+          cmake --build . --config Release
+          ctest --output-on-failure --no-tests=error -C Release
+
+  windows-cmake-install:
+    strategy:
+      fail-fast: false
+      matrix:
+        include:
+          - os: windows-2019
+          - os: windows-2022
+
+    runs-on: ${{matrix.os}}
+
+    steps:
+      - uses: actions/checkout@v3
+
+      - name: Setup Boost
+        shell: cmd
+        run: |
+          echo GITHUB_REPOSITORY: %GITHUB_REPOSITORY%
+          for /f %%i in ("%GITHUB_REPOSITORY%") do set LIBRARY=%%~nxi
+          echo LIBRARY: %LIBRARY%
+          echo LIBRARY=%LIBRARY%>>%GITHUB_ENV%
+          echo GITHUB_BASE_REF: %GITHUB_BASE_REF%
+          echo GITHUB_REF: %GITHUB_REF%
+          if "%GITHUB_BASE_REF%" == "" set GITHUB_BASE_REF=%GITHUB_REF%
+          set BOOST_BRANCH=develop
+          for /f %%i in ("%GITHUB_BASE_REF%") do if "%%~nxi" == "master" set BOOST_BRANCH=master
+          echo BOOST_BRANCH: %BOOST_BRANCH%
+          cd ..
+          git clone -b %BOOST_BRANCH% --depth 1 https://github.com/boostorg/boost.git boost-root
+          cd boost-root
+          xcopy /s /e /q %GITHUB_WORKSPACE% libs\%LIBRARY%\
+          git submodule update --init tools/boostdep
+          python tools/boostdep/depinst/depinst.py --git_args "--jobs 3" %LIBRARY%
+
+      - name: Configure
+        shell: cmd
+        run: |
+          cd ../boost-root
+          mkdir __build__ && cd __build__
+          cmake -DBOOST_INCLUDE_LIBRARIES=%LIBRARY% -DCMAKE_INSTALL_PREFIX=C:/cmake-prefix ..
+
+      - name: Install (Debug)
+        shell: cmd
+        run: |
+          cd ../boost-root/__build__
+          cmake --build . --target install --config Debug
+
+      - name: Install (Release)
+        shell: cmd
+        run: |
+          cd ../boost-root/__build__
+          cmake --build . --target install --config Release
+
+      - name: Use the installed library (Debug)
+        shell: cmd
+        run: |
+          cd ../boost-root/libs/%LIBRARY%/test/cmake_install_test && mkdir __build__ && cd __build__
+          cmake -DCMAKE_INSTALL_PREFIX=C:/cmake-prefix ..
+          cmake --build . --config Debug
+          ctest --output-on-failure --no-tests=error -C Debug
+
+      - name: Use the installed library (Release)
+        shell: cmd
+        run: |
+          cd ../boost-root/libs/%LIBRARY%/test/cmake_install_test/__build__
+          cmake --build . --config Release
+          ctest --output-on-failure --no-tests=error -C Release
+
+  windows-cmake-test:
+    strategy:
+      fail-fast: false
+      matrix:
+        include:
+          - os: windows-2019
+          - os: windows-2022
+
+    runs-on: ${{matrix.os}}
+
+    steps:
+      - uses: actions/checkout@v3
+
+      - name: Setup Boost
+        shell: cmd
+        run: |
+          echo GITHUB_REPOSITORY: %GITHUB_REPOSITORY%
+          for /f %%i in ("%GITHUB_REPOSITORY%") do set LIBRARY=%%~nxi
+          echo LIBRARY: %LIBRARY%
+          echo LIBRARY=%LIBRARY%>>%GITHUB_ENV%
+          echo GITHUB_BASE_REF: %GITHUB_BASE_REF%
+          echo GITHUB_REF: %GITHUB_REF%
+          if "%GITHUB_BASE_REF%" == "" set GITHUB_BASE_REF=%GITHUB_REF%
+          set BOOST_BRANCH=develop
+          for /f %%i in ("%GITHUB_BASE_REF%") do if "%%~nxi" == "master" set BOOST_BRANCH=master
+          echo BOOST_BRANCH: %BOOST_BRANCH%
+          cd ..
+          git clone -b %BOOST_BRANCH% --depth 1 https://github.com/boostorg/boost.git boost-root
+          cd boost-root
+          xcopy /s /e /q %GITHUB_WORKSPACE% libs\%LIBRARY%\
+          git submodule update --init tools/boostdep
+          python tools/boostdep/depinst/depinst.py --git_args "--jobs 3" %LIBRARY%
+
+      - name: Configure
+        shell: cmd
+        run: |
+          cd ../boost-root
+          mkdir __build__ && cd __build__
+          cmake -DBOOST_INCLUDE_LIBRARIES=%LIBRARY% -DBUILD_TESTING=ON ..
+
+      - name: Build tests (Debug)
+        shell: cmd
+        run: |
+          cd ../boost-root/__build__
+          cmake --build . --target tests --config Debug
+
+      - name: Run tests (Debug)
+        shell: cmd
+        run: |
+          cd ../boost-root/__build__
+          ctest --output-on-failure --no-tests=error -C Debug
+
+      - name: Build tests (Release)
+        shell: cmd
+        run: |
+          cd ../boost-root/__build__
+          cmake --build . --target tests --config Release
+
+      - name: Run tests (Release)
+        shell: cmd
+        run: |
+          cd ../boost-root/__build__
+          ctest --output-on-failure --no-tests=error -C Release
--- a/appveyor.yml
+++ b/appveyor.yml
@@ -18,16 +18,12 @@ environment:
      TOOLSET: msvc-9.0,msvc-10.0,msvc-11.0
      ADDRMD: 32
    - APPVEYOR_BUILD_WORKER_IMAGE: Visual Studio 2015
-      TOOLSET: msvc-12.0,msvc-14.0
+      TOOLSET: msvc-12.0
      ADDRMD: 32,64
    - APPVEYOR_BUILD_WORKER_IMAGE: Visual Studio 2017
      TOOLSET: msvc-14.1,clang-win
      CXXSTD: 14,17
      ADDRMD: 32,64
-    - APPVEYOR_BUILD_WORKER_IMAGE: Visual Studio 2019
-      TOOLSET: msvc-14.2
-      CXXSTD: 14,17,latest
-      ADDRMD: 32,64
    - APPVEYOR_BUILD_WORKER_IMAGE: Visual Studio 2015
      ADDPATH: C:\cygwin\bin;
      TOOLSET: gcc
--- a/include/boost/bind/apply.hpp
+++ b/include/boost/bind/apply.hpp
@@ -11,6 +11,7 @@
 // http://www.boost.org/LICENSE_1_0.txt)
 //

+#include <boost/bind/detail/requires_cxx11.hpp>
 #include <boost/config.hpp>

 namespace boost
--- a/include/boost/bind/bind.hpp
+++ b/include/boost/bind/bind.hpp
@@ -21,18 +21,19 @@
 //  See http://www.boost.org/libs/bind/bind.html for documentation.
 //

+#include <boost/bind/detail/requires_cxx11.hpp>
 #include <boost/config.hpp>
-#include <boost/ref.hpp>
-#include <boost/mem_fn.hpp>
+#include <boost/bind/mem_fn.hpp>
 #include <boost/type.hpp>
 #include <boost/is_placeholder.hpp>
 #include <boost/bind/arg.hpp>
 #include <boost/bind/detail/result_traits.hpp>
 #include <boost/bind/std_placeholders.hpp>
-#include <boost/detail/workaround.hpp>
+#include <boost/config/workaround.hpp>
 #include <boost/visit_each.hpp>
+#include <boost/core/ref.hpp>
 #include <boost/core/enable_if.hpp>
-#include <boost/core/is_same.hpp>
+#include <boost/bind/detail/is_same.hpp>

 #if !defined( BOOST_NO_CXX11_RVALUE_REFERENCES )
 #include <utility> // std::forward
@@ -844,7 +845,7 @@ public:

 // bind_t

-#if !defined( BOOST_NO_CXX11_RVALUE_REFERENCES )
+#if !defined(BOOST_NO_CXX11_RVALUE_REFERENCES) && !(defined(BOOST_GCC) && BOOST_GCC < 40600)

 template< class A1 > class rrlist1
 {
@@ -1415,7 +1416,7 @@ public:
    }
 };

-#elif !defined( BOOST_NO_VOID_RETURNS )
+#else

 template<class R, class F, class L> class bind_t
 {
@@ -1425,61 +1426,7 @@ public:

    bind_t(F f, L const & l): f_(f), l_(l) {}

-#define BOOST_BIND_RETURN return
 #include <boost/bind/bind_template.hpp>
-#undef BOOST_BIND_RETURN
-
-};
-
-#else // no void returns
-
-template<class R> struct bind_t_generator
-{
-
-template<class F, class L> class implementation
-{
-public:
-
-    typedef implementation this_type;
-
-    implementation(F f, L const & l): f_(f), l_(l) {}
-
-#define BOOST_BIND_RETURN return
-#include <boost/bind/bind_template.hpp>
-#undef BOOST_BIND_RETURN
-
-};
-
-};
-
-template<> struct bind_t_generator<void>
-{
-
-template<class F, class L> class implementation
-{
-private:
-
-    typedef void R;
-
-public:
-
-    typedef implementation this_type;
-
-    implementation(F f, L const & l): f_(f), l_(l) {}
-
-#define BOOST_BIND_RETURN
-#include <boost/bind/bind_template.hpp>
-#undef BOOST_BIND_RETURN
-
-};
-
-};
-
-template<class R2, class F, class L> class bind_t: public bind_t_generator<R2>::BOOST_NESTED_TEMPLATE implementation<F, L>
-{
-public:
-
-    bind_t(F f, L const & l): bind_t_generator<R2>::BOOST_NESTED_TEMPLATE implementation<F, L>(f, l) {}

 };

--- a/include/boost/bind/bind_mf_cc.hpp
+++ b/include/boost/bind/bind_mf_cc.hpp
@@ -36,7 +36,7 @@ template<class R, class T,

 template<class Rt2, class R, class T,
    class A1>
-    typename boost::enable_if_c<!boost::core::is_same<Rt2, R>::value,
+    typename boost::enable_if_c<!_bi::is_same<Rt2, R>::value,
    _bi::bind_t<Rt2, _mfi::BOOST_BIND_MF_NAME(mf0)<R, T>, typename _bi::list_av_1<A1>::type>
    >::type BOOST_BIND(R (BOOST_BIND_MF_CC T::*f) () BOOST_BIND_MF_NOEXCEPT, A1 a1)
 {
@@ -47,7 +47,7 @@ template<class Rt2, class R, class T,

 template<class Rt2, class R, class T,
    class A1>
-    typename boost::enable_if_c<!boost::core::is_same<Rt2, R>::value,
+    typename boost::enable_if_c<!_bi::is_same<Rt2, R>::value,
    _bi::bind_t<Rt2, _mfi::BOOST_BIND_MF_NAME(cmf0)<R, T>, typename _bi::list_av_1<A1>::type>
    >::type BOOST_BIND(R (BOOST_BIND_MF_CC T::*f) () const BOOST_BIND_MF_NOEXCEPT, A1 a1)
 {
@@ -83,7 +83,7 @@ template<class R, class T,
 template<class Rt2, class R, class T,
    class B1,
    class A1, class A2>
-    typename boost::enable_if_c<!boost::core::is_same<Rt2, R>::value,
+    typename boost::enable_if_c<!_bi::is_same<Rt2, R>::value,
    _bi::bind_t<Rt2, _mfi::BOOST_BIND_MF_NAME(mf1)<R, T, B1>, typename _bi::list_av_2<A1, A2>::type>
    >::type BOOST_BIND(R (BOOST_BIND_MF_CC T::*f) (B1) BOOST_BIND_MF_NOEXCEPT, A1 a1, A2 a2)
 {
@@ -95,7 +95,7 @@ template<class Rt2, class R, class T,
 template<class Rt2, class R, class T,
    class B1,
    class A1, class A2>
-    typename boost::enable_if_c<!boost::core::is_same<Rt2, R>::value,
+    typename boost::enable_if_c<!_bi::is_same<Rt2, R>::value,
    _bi::bind_t<Rt2, _mfi::BOOST_BIND_MF_NAME(cmf1)<R, T, B1>, typename _bi::list_av_2<A1, A2>::type>
    >::type BOOST_BIND(R (BOOST_BIND_MF_CC T::*f) (B1) const BOOST_BIND_MF_NOEXCEPT, A1 a1, A2 a2)
 {
@@ -131,7 +131,7 @@ template<class R, class T,
 template<class Rt2, class R, class T,
    class B1, class B2,
    class A1, class A2, class A3>
-    typename boost::enable_if_c<!boost::core::is_same<Rt2, R>::value,
+    typename boost::enable_if_c<!_bi::is_same<Rt2, R>::value,
    _bi::bind_t<Rt2, _mfi::BOOST_BIND_MF_NAME(mf2)<R, T, B1, B2>, typename _bi::list_av_3<A1, A2, A3>::type>
    >::type BOOST_BIND(R (BOOST_BIND_MF_CC T::*f) (B1, B2) BOOST_BIND_MF_NOEXCEPT, A1 a1, A2 a2, A3 a3)
 {
@@ -143,7 +143,7 @@ template<class Rt2, class R, class T,
 template<class Rt2, class R, class T,
    class B1, class B2,
    class A1, class A2, class A3>
-    typename boost::enable_if_c<!boost::core::is_same<Rt2, R>::value,
+    typename boost::enable_if_c<!_bi::is_same<Rt2, R>::value,
    _bi::bind_t<Rt2, _mfi::BOOST_BIND_MF_NAME(cmf2)<R, T, B1, B2>, typename _bi::list_av_3<A1, A2, A3>::type>
    >::type BOOST_BIND(R (BOOST_BIND_MF_CC T::*f) (B1, B2) const BOOST_BIND_MF_NOEXCEPT, A1 a1, A2 a2, A3 a3)
 {
@@ -179,7 +179,7 @@ template<class R, class T,
 template<class Rt2, class R, class T,
    class B1, class B2, class B3,
    class A1, class A2, class A3, class A4>
-    typename boost::enable_if_c<!boost::core::is_same<Rt2, R>::value,
+    typename boost::enable_if_c<!_bi::is_same<Rt2, R>::value,
    _bi::bind_t<Rt2, _mfi::BOOST_BIND_MF_NAME(mf3)<R, T, B1, B2, B3>, typename _bi::list_av_4<A1, A2, A3, A4>::type>
    >::type BOOST_BIND(R (BOOST_BIND_MF_CC T::*f) (B1, B2, B3) BOOST_BIND_MF_NOEXCEPT, A1 a1, A2 a2, A3 a3, A4 a4)
 {
@@ -191,7 +191,7 @@ template<class Rt2, class R, class T,
 template<class Rt2, class R, class T,
    class B1, class B2, class B3,
    class A1, class A2, class A3, class A4>
-    typename boost::enable_if_c<!boost::core::is_same<Rt2, R>::value,
+    typename boost::enable_if_c<!_bi::is_same<Rt2, R>::value,
    _bi::bind_t<Rt2, _mfi::BOOST_BIND_MF_NAME(cmf3)<R, T, B1, B2, B3>, typename _bi::list_av_4<A1, A2, A3, A4>::type>
    >::type BOOST_BIND(R (BOOST_BIND_MF_CC T::*f) (B1, B2, B3) const BOOST_BIND_MF_NOEXCEPT, A1 a1, A2 a2, A3 a3, A4 a4)
 {
@@ -227,7 +227,7 @@ template<class R, class T,
 template<class Rt2, class R, class T,
    class B1, class B2, class B3, class B4,
    class A1, class A2, class A3, class A4, class A5>
-    typename boost::enable_if_c<!boost::core::is_same<Rt2, R>::value,
+    typename boost::enable_if_c<!_bi::is_same<Rt2, R>::value,
    _bi::bind_t<Rt2, _mfi::BOOST_BIND_MF_NAME(mf4)<R, T, B1, B2, B3, B4>, typename _bi::list_av_5<A1, A2, A3, A4, A5>::type>
    >::type BOOST_BIND(R (BOOST_BIND_MF_CC T::*f) (B1, B2, B3, B4) BOOST_BIND_MF_NOEXCEPT, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5)
 {
@@ -239,7 +239,7 @@ template<class Rt2, class R, class T,
 template<class Rt2, class R, class T,
    class B1, class B2, class B3, class B4,
    class A1, class A2, class A3, class A4, class A5>
-    typename boost::enable_if_c<!boost::core::is_same<Rt2, R>::value,
+    typename boost::enable_if_c<!_bi::is_same<Rt2, R>::value,
    _bi::bind_t<Rt2, _mfi::BOOST_BIND_MF_NAME(cmf4)<R, T, B1, B2, B3, B4>, typename _bi::list_av_5<A1, A2, A3, A4, A5>::type>
    >::type BOOST_BIND(R (BOOST_BIND_MF_CC T::*f) (B1, B2, B3, B4) const BOOST_BIND_MF_NOEXCEPT, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5)
 {
@@ -275,7 +275,7 @@ template<class R, class T,
 template<class Rt2, class R, class T,
    class B1, class B2, class B3, class B4, class B5,
    class A1, class A2, class A3, class A4, class A5, class A6>
-    typename boost::enable_if_c<!boost::core::is_same<Rt2, R>::value,
+    typename boost::enable_if_c<!_bi::is_same<Rt2, R>::value,
    _bi::bind_t<Rt2, _mfi::BOOST_BIND_MF_NAME(mf5)<R, T, B1, B2, B3, B4, B5>, typename _bi::list_av_6<A1, A2, A3, A4, A5, A6>::type>
    >::type BOOST_BIND(R (BOOST_BIND_MF_CC T::*f) (B1, B2, B3, B4, B5) BOOST_BIND_MF_NOEXCEPT, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6)
 {
@@ -287,7 +287,7 @@ template<class Rt2, class R, class T,
 template<class Rt2, class R, class T,
    class B1, class B2, class B3, class B4, class B5,
    class A1, class A2, class A3, class A4, class A5, class A6>
-    typename boost::enable_if_c<!boost::core::is_same<Rt2, R>::value,
+    typename boost::enable_if_c<!_bi::is_same<Rt2, R>::value,
    _bi::bind_t<Rt2, _mfi::BOOST_BIND_MF_NAME(cmf5)<R, T, B1, B2, B3, B4, B5>, typename _bi::list_av_6<A1, A2, A3, A4, A5, A6>::type>
    >::type BOOST_BIND(R (BOOST_BIND_MF_CC T::*f) (B1, B2, B3, B4, B5) const BOOST_BIND_MF_NOEXCEPT, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6)
 {
@@ -323,7 +323,7 @@ template<class R, class T,
 template<class Rt2, class R, class T,
    class B1, class B2, class B3, class B4, class B5, class B6,
    class A1, class A2, class A3, class A4, class A5, class A6, class A7>
-    typename boost::enable_if_c<!boost::core::is_same<Rt2, R>::value,
+    typename boost::enable_if_c<!_bi::is_same<Rt2, R>::value,
    _bi::bind_t<Rt2, _mfi::BOOST_BIND_MF_NAME(mf6)<R, T, B1, B2, B3, B4, B5, B6>, typename _bi::list_av_7<A1, A2, A3, A4, A5, A6, A7>::type>
    >::type BOOST_BIND(R (BOOST_BIND_MF_CC T::*f) (B1, B2, B3, B4, B5, B6) BOOST_BIND_MF_NOEXCEPT, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7)
 {
@@ -335,7 +335,7 @@ template<class Rt2, class R, class T,
 template<class Rt2, class R, class T,
    class B1, class B2, class B3, class B4, class B5, class B6,
    class A1, class A2, class A3, class A4, class A5, class A6, class A7>
-    typename boost::enable_if_c<!boost::core::is_same<Rt2, R>::value,
+    typename boost::enable_if_c<!_bi::is_same<Rt2, R>::value,
    _bi::bind_t<Rt2, _mfi::BOOST_BIND_MF_NAME(cmf6)<R, T, B1, B2, B3, B4, B5, B6>, typename _bi::list_av_7<A1, A2, A3, A4, A5, A6, A7>::type>
    >::type BOOST_BIND(R (BOOST_BIND_MF_CC T::*f) (B1, B2, B3, B4, B5, B6) const BOOST_BIND_MF_NOEXCEPT, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7)
 {
@@ -371,7 +371,7 @@ template<class R, class T,
 template<class Rt2, class R, class T,
    class B1, class B2, class B3, class B4, class B5, class B6, class B7,
    class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8>
-    typename boost::enable_if_c<!boost::core::is_same<Rt2, R>::value,
+    typename boost::enable_if_c<!_bi::is_same<Rt2, R>::value,
    _bi::bind_t<Rt2, _mfi::BOOST_BIND_MF_NAME(mf7)<R, T, B1, B2, B3, B4, B5, B6, B7>, typename _bi::list_av_8<A1, A2, A3, A4, A5, A6, A7, A8>::type>
    >::type BOOST_BIND(R (BOOST_BIND_MF_CC T::*f) (B1, B2, B3, B4, B5, B6, B7) BOOST_BIND_MF_NOEXCEPT, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8)
 {
@@ -383,7 +383,7 @@ template<class Rt2, class R, class T,
 template<class Rt2, class R, class T,
    class B1, class B2, class B3, class B4, class B5, class B6, class B7,
    class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8>
-    typename boost::enable_if_c<!boost::core::is_same<Rt2, R>::value,
+    typename boost::enable_if_c<!_bi::is_same<Rt2, R>::value,
    _bi::bind_t<Rt2, _mfi::BOOST_BIND_MF_NAME(cmf7)<R, T, B1, B2, B3, B4, B5, B6, B7>, typename _bi::list_av_8<A1, A2, A3, A4, A5, A6, A7, A8>::type>
    >::type BOOST_BIND(R (BOOST_BIND_MF_CC T::*f) (B1, B2, B3, B4, B5, B6, B7) const BOOST_BIND_MF_NOEXCEPT, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8)
 {
@@ -419,7 +419,7 @@ template<class R, class T,
 template<class Rt2, class R, class T,
    class B1, class B2, class B3, class B4, class B5, class B6, class B7, class B8,
    class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9>
-    typename boost::enable_if_c<!boost::core::is_same<Rt2, R>::value,
+    typename boost::enable_if_c<!_bi::is_same<Rt2, R>::value,
    _bi::bind_t<Rt2, _mfi::BOOST_BIND_MF_NAME(mf8)<R, T, B1, B2, B3, B4, B5, B6, B7, B8>, typename _bi::list_av_9<A1, A2, A3, A4, A5, A6, A7, A8, A9>::type>
    >::type BOOST_BIND(R (BOOST_BIND_MF_CC T::*f) (B1, B2, B3, B4, B5, B6, B7, B8) BOOST_BIND_MF_NOEXCEPT, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9)
 {
@@ -431,7 +431,7 @@ template<class Rt2, class R, class T,
 template<class Rt2, class R, class T,
    class B1, class B2, class B3, class B4, class B5, class B6, class B7, class B8,
    class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9>
-    typename boost::enable_if_c<!boost::core::is_same<Rt2, R>::value,
+    typename boost::enable_if_c<!_bi::is_same<Rt2, R>::value,
    _bi::bind_t<Rt2, _mfi::BOOST_BIND_MF_NAME(cmf8)<R, T, B1, B2, B3, B4, B5, B6, B7, B8>, typename _bi::list_av_9<A1, A2, A3, A4, A5, A6, A7, A8, A9>::type>
    >::type BOOST_BIND(R (BOOST_BIND_MF_CC T::*f) (B1, B2, B3, B4, B5, B6, B7, B8) const BOOST_BIND_MF_NOEXCEPT, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9)
 {
--- a/include/boost/bind/bind_template.hpp
+++ b/include/boost/bind/bind_template.hpp
@@ -17,25 +17,25 @@
    result_type operator()()
    {
        list0 a;
-        BOOST_BIND_RETURN l_(type<result_type>(), f_, a, 0);
+        return l_(type<result_type>(), f_, a, 0);
    }

    result_type operator()() const
    {
        list0 a;
-        BOOST_BIND_RETURN l_(type<result_type>(), f_, a, 0);
+        return l_(type<result_type>(), f_, a, 0);
    }

    template<class A1> result_type operator()(A1 & a1)
    {
        list1<A1 &> a(a1);
-        BOOST_BIND_RETURN l_(type<result_type>(), f_, a, 0);
+        return l_(type<result_type>(), f_, a, 0);
    }

    template<class A1> result_type operator()(A1 & a1) const
    {
        list1<A1 &> a(a1);
-        BOOST_BIND_RETURN l_(type<result_type>(), f_, a, 0);
+        return l_(type<result_type>(), f_, a, 0);
    }

 #if !defined(BOOST_NO_FUNCTION_TEMPLATE_ORDERING) \
@@ -44,13 +44,13 @@
    template<class A1> result_type operator()(A1 const & a1)
    {
        list1<A1 const &> a(a1);
-        BOOST_BIND_RETURN l_(type<result_type>(), f_, a, 0);
+        return l_(type<result_type>(), f_, a, 0);
    }

    template<class A1> result_type operator()(A1 const & a1) const
    {
        list1<A1 const &> a(a1);
-        BOOST_BIND_RETURN l_(type<result_type>(), f_, a, 0);
+        return l_(type<result_type>(), f_, a, 0);
    }

 #endif
@@ -58,13 +58,13 @@
    template<class A1, class A2> result_type operator()(A1 & a1, A2 & a2)
    {
        list2<A1 &, A2 &> a(a1, a2);
-        BOOST_BIND_RETURN l_(type<result_type>(), f_, a, 0);
+        return l_(type<result_type>(), f_, a, 0);
    }

    template<class A1, class A2> result_type operator()(A1 & a1, A2 & a2) const
    {
        list2<A1 &, A2 &> a(a1, a2);
-        BOOST_BIND_RETURN l_(type<result_type>(), f_, a, 0);
+        return l_(type<result_type>(), f_, a, 0);
    }

 #if !defined(BOOST_NO_FUNCTION_TEMPLATE_ORDERING) \
@@ -73,39 +73,39 @@
    template<class A1, class A2> result_type operator()(A1 const & a1, A2 & a2)
    {
        list2<A1 const &, A2 &> a(a1, a2);
-        BOOST_BIND_RETURN l_(type<result_type>(), f_, a, 0);
+        return l_(type<result_type>(), f_, a, 0);
    }

    template<class A1, class A2> result_type operator()(A1 const & a1, A2 & a2) const
    {
        list2<A1 const &, A2 &> a(a1, a2);
-        BOOST_BIND_RETURN l_(type<result_type>(), f_, a, 0);
+        return l_(type<result_type>(), f_, a, 0);
    }


    template<class A1, class A2> result_type operator()(A1 & a1, A2 const & a2)
    {
        list2<A1 &, A2 const &> a(a1, a2);
-        BOOST_BIND_RETURN l_(type<result_type>(), f_, a, 0);
+        return l_(type<result_type>(), f_, a, 0);
    }

    template<class A1, class A2> result_type operator()(A1 & a1, A2 const & a2) const
    {
        list2<A1 &, A2 const &> a(a1, a2);
-        BOOST_BIND_RETURN l_(type<result_type>(), f_, a, 0);
+        return l_(type<result_type>(), f_, a, 0);
    }


    template<class A1, class A2> result_type operator()(A1 const & a1, A2 const & a2)
    {
        list2<A1 const &, A2 const &> a(a1, a2);
-        BOOST_BIND_RETURN l_(type<result_type>(), f_, a, 0);
+        return l_(type<result_type>(), f_, a, 0);
    }

    template<class A1, class A2> result_type operator()(A1 const & a1, A2 const & a2) const
    {
        list2<A1 const &, A2 const &> a(a1, a2);
-        BOOST_BIND_RETURN l_(type<result_type>(), f_, a, 0);
+        return l_(type<result_type>(), f_, a, 0);
    }

 #endif
@@ -113,13 +113,13 @@
    template<class A1, class A2, class A3> result_type operator()(A1 & a1, A2 & a2, A3 & a3)
    {
        list3<A1 &, A2 &, A3 &> a(a1, a2, a3);
-        BOOST_BIND_RETURN l_(type<result_type>(), f_, a, 0);
+        return l_(type<result_type>(), f_, a, 0);
    }

    template<class A1, class A2, class A3> result_type operator()(A1 & a1, A2 & a2, A3 & a3) const
    {
        list3<A1 &, A2 &, A3 &> a(a1, a2, a3);
-        BOOST_BIND_RETURN l_(type<result_type>(), f_, a, 0);
+        return l_(type<result_type>(), f_, a, 0);
    }

 #if !defined(BOOST_NO_FUNCTION_TEMPLATE_ORDERING) \
@@ -128,13 +128,13 @@
    template<class A1, class A2, class A3> result_type operator()(A1 const & a1, A2 const & a2, A3 const & a3)
    {
        list3<A1 const &, A2 const &, A3 const &> a(a1, a2, a3);
-        BOOST_BIND_RETURN l_(type<result_type>(), f_, a, 0);
+        return l_(type<result_type>(), f_, a, 0);
    }

    template<class A1, class A2, class A3> result_type operator()(A1 const & a1, A2 const & a2, A3 const & a3) const
    {
        list3<A1 const &, A2 const &, A3 const &> a(a1, a2, a3);
-        BOOST_BIND_RETURN l_(type<result_type>(), f_, a, 0);
+        return l_(type<result_type>(), f_, a, 0);
    }

 #endif
@@ -142,13 +142,13 @@
    template<class A1, class A2, class A3, class A4> result_type operator()(A1 & a1, A2 & a2, A3 & a3, A4 & a4)
    {
        list4<A1 &, A2 &, A3 &, A4 &> a(a1, a2, a3, a4);
-        BOOST_BIND_RETURN l_(type<result_type>(), f_, a, 0);
+        return l_(type<result_type>(), f_, a, 0);
    }

    template<class A1, class A2, class A3, class A4> result_type operator()(A1 & a1, A2 & a2, A3 & a3, A4 & a4) const
    {
        list4<A1 &, A2 &, A3 &, A4 &> a(a1, a2, a3, a4);
-        BOOST_BIND_RETURN l_(type<result_type>(), f_, a, 0);
+        return l_(type<result_type>(), f_, a, 0);
    }

 #if !defined(BOOST_NO_FUNCTION_TEMPLATE_ORDERING) \
@@ -157,13 +157,13 @@
    template<class A1, class A2, class A3, class A4> result_type operator()(A1 const & a1, A2 const & a2, A3 const & a3, A4 const & a4)
    {
        list4<A1 const &, A2 const &, A3 const &, A4 const &> a(a1, a2, a3, a4);
-        BOOST_BIND_RETURN l_(type<result_type>(), f_, a, 0);
+        return l_(type<result_type>(), f_, a, 0);
    }

    template<class A1, class A2, class A3, class A4> result_type operator()(A1 const & a1, A2 const & a2, A3 const & a3, A4 const & a4) const
    {
        list4<A1 const &, A2 const &, A3 const &, A4 const &> a(a1, a2, a3, a4);
-        BOOST_BIND_RETURN l_(type<result_type>(), f_, a, 0);
+        return l_(type<result_type>(), f_, a, 0);
    }

 #endif
@@ -171,13 +171,13 @@
    template<class A1, class A2, class A3, class A4, class A5> result_type operator()(A1 & a1, A2 & a2, A3 & a3, A4 & a4, A5 & a5)
    {
        list5<A1 &, A2 &, A3 &, A4 &, A5 &> a(a1, a2, a3, a4, a5);
-        BOOST_BIND_RETURN l_(type<result_type>(), f_, a, 0);
+        return l_(type<result_type>(), f_, a, 0);
    }

    template<class A1, class A2, class A3, class A4, class A5> result_type operator()(A1 & a1, A2 & a2, A3 & a3, A4 & a4, A5 & a5) const
    {
        list5<A1 &, A2 &, A3 &, A4 &, A5 &> a(a1, a2, a3, a4, a5);
-        BOOST_BIND_RETURN l_(type<result_type>(), f_, a, 0);
+        return l_(type<result_type>(), f_, a, 0);
    }

 #if !defined(BOOST_NO_FUNCTION_TEMPLATE_ORDERING) \
@@ -186,13 +186,13 @@
    template<class A1, class A2, class A3, class A4, class A5> result_type operator()(A1 const & a1, A2 const & a2, A3 const & a3, A4 const & a4, A5 const & a5)
    {
        list5<A1 const &, A2 const &, A3 const &, A4 const &, A5 const &> a(a1, a2, a3, a4, a5);
-        BOOST_BIND_RETURN l_(type<result_type>(), f_, a, 0);
+        return l_(type<result_type>(), f_, a, 0);
    }

    template<class A1, class A2, class A3, class A4, class A5> result_type operator()(A1 const & a1, A2 const & a2, A3 const & a3, A4 const & a4, A5 const & a5) const
    {
        list5<A1 const &, A2 const &, A3 const &, A4 const &, A5 const &> a(a1, a2, a3, a4, a5);
-        BOOST_BIND_RETURN l_(type<result_type>(), f_, a, 0);
+        return l_(type<result_type>(), f_, a, 0);
    }

 #endif
@@ -200,13 +200,13 @@
    template<class A1, class A2, class A3, class A4, class A5, class A6> result_type operator()(A1 & a1, A2 & a2, A3 & a3, A4 & a4, A5 & a5, A6 & a6)
    {
        list6<A1 &, A2 &, A3 &, A4 &, A5 &, A6 &> a(a1, a2, a3, a4, a5, a6);
-        BOOST_BIND_RETURN l_(type<result_type>(), f_, a, 0);
+        return l_(type<result_type>(), f_, a, 0);
    }

    template<class A1, class A2, class A3, class A4, class A5, class A6> result_type operator()(A1 & a1, A2 & a2, A3 & a3, A4 & a4, A5 & a5, A6 & a6) const
    {
        list6<A1 &, A2 &, A3 &, A4 &, A5 &, A6 &> a(a1, a2, a3, a4, a5, a6);
-        BOOST_BIND_RETURN l_(type<result_type>(), f_, a, 0);
+        return l_(type<result_type>(), f_, a, 0);
    }

 #if !defined(BOOST_NO_FUNCTION_TEMPLATE_ORDERING) \
@@ -215,13 +215,13 @@
    template<class A1, class A2, class A3, class A4, class A5, class A6> result_type operator()(A1 const & a1, A2 const & a2, A3 const & a3, A4 const & a4, A5 const & a5, A6 const & a6)
    {
        list6<A1 const &, A2 const &, A3 const &, A4 const &, A5 const &, A6 const &> a(a1, a2, a3, a4, a5, a6);
-        BOOST_BIND_RETURN l_(type<result_type>(), f_, a, 0);
+        return l_(type<result_type>(), f_, a, 0);
    }

    template<class A1, class A2, class A3, class A4, class A5, class A6> result_type operator()(A1 const & a1, A2 const & a2, A3 const & a3, A4 const & a4, A5 const & a5, A6 const & a6) const
    {
        list6<A1 const &, A2 const &, A3 const &, A4 const &, A5 const &, A6 const &> a(a1, a2, a3, a4, a5, a6);
-        BOOST_BIND_RETURN l_(type<result_type>(), f_, a, 0);
+        return l_(type<result_type>(), f_, a, 0);
    }

 #endif
@@ -229,13 +229,13 @@
    template<class A1, class A2, class A3, class A4, class A5, class A6, class A7> result_type operator()(A1 & a1, A2 & a2, A3 & a3, A4 & a4, A5 & a5, A6 & a6, A7 & a7)
    {
        list7<A1 &, A2 &, A3 &, A4 &, A5 &, A6 &, A7 &> a(a1, a2, a3, a4, a5, a6, a7);
-        BOOST_BIND_RETURN l_(type<result_type>(), f_, a, 0);
+        return l_(type<result_type>(), f_, a, 0);
    }

    template<class A1, class A2, class A3, class A4, class A5, class A6, class A7> result_type operator()(A1 & a1, A2 & a2, A3 & a3, A4 & a4, A5 & a5, A6 & a6, A7 & a7) const
    {
        list7<A1 &, A2 &, A3 &, A4 &, A5 &, A6 &, A7 &> a(a1, a2, a3, a4, a5, a6, a7);
-        BOOST_BIND_RETURN l_(type<result_type>(), f_, a, 0);
+        return l_(type<result_type>(), f_, a, 0);
    }

 #if !defined(BOOST_NO_FUNCTION_TEMPLATE_ORDERING) \
@@ -244,13 +244,13 @@
    template<class A1, class A2, class A3, class A4, class A5, class A6, class A7> result_type operator()(A1 const & a1, A2 const & a2, A3 const & a3, A4 const & a4, A5 const & a5, A6 const & a6, A7 const & a7)
    {
        list7<A1 const &, A2 const &, A3 const &, A4 const &, A5 const &, A6 const &, A7 const &> a(a1, a2, a3, a4, a5, a6, a7);
-        BOOST_BIND_RETURN l_(type<result_type>(), f_, a, 0);
+        return l_(type<result_type>(), f_, a, 0);
    }

    template<class A1, class A2, class A3, class A4, class A5, class A6, class A7> result_type operator()(A1 const & a1, A2 const & a2, A3 const & a3, A4 const & a4, A5 const & a5, A6 const & a6, A7 const & a7) const
    {
        list7<A1 const &, A2 const &, A3 const &, A4 const &, A5 const &, A6 const &, A7 const &> a(a1, a2, a3, a4, a5, a6, a7);
-        BOOST_BIND_RETURN l_(type<result_type>(), f_, a, 0);
+        return l_(type<result_type>(), f_, a, 0);
    }

 #endif
@@ -258,13 +258,13 @@
    template<class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8> result_type operator()(A1 & a1, A2 & a2, A3 & a3, A4 & a4, A5 & a5, A6 & a6, A7 & a7, A8 & a8)
    {
        list8<A1 &, A2 &, A3 &, A4 &, A5 &, A6 &, A7 &, A8 &> a(a1, a2, a3, a4, a5, a6, a7, a8);
-        BOOST_BIND_RETURN l_(type<result_type>(), f_, a, 0);
+        return l_(type<result_type>(), f_, a, 0);
    }

    template<class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8> result_type operator()(A1 & a1, A2 & a2, A3 & a3, A4 & a4, A5 & a5, A6 & a6, A7 & a7, A8 & a8) const
    {
        list8<A1 &, A2 &, A3 &, A4 &, A5 &, A6 &, A7 &, A8 &> a(a1, a2, a3, a4, a5, a6, a7, a8);
-        BOOST_BIND_RETURN l_(type<result_type>(), f_, a, 0);
+        return l_(type<result_type>(), f_, a, 0);
    }

 #if !defined(BOOST_NO_FUNCTION_TEMPLATE_ORDERING) \
@@ -273,13 +273,13 @@
    template<class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8> result_type operator()(A1 const & a1, A2 const & a2, A3 const & a3, A4 const & a4, A5 const & a5, A6 const & a6, A7 const & a7, A8 const & a8)
    {
        list8<A1 const &, A2 const &, A3 const &, A4 const &, A5 const &, A6 const &, A7 const &, A8 const &> a(a1, a2, a3, a4, a5, a6, a7, a8);
-        BOOST_BIND_RETURN l_(type<result_type>(), f_, a, 0);
+        return l_(type<result_type>(), f_, a, 0);
    }

    template<class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8> result_type operator()(A1 const & a1, A2 const & a2, A3 const & a3, A4 const & a4, A5 const & a5, A6 const & a6, A7 const & a7, A8 const & a8) const
    {
        list8<A1 const &, A2 const &, A3 const &, A4 const &, A5 const &, A6 const &, A7 const &, A8 const &> a(a1, a2, a3, a4, a5, a6, a7, a8);
-        BOOST_BIND_RETURN l_(type<result_type>(), f_, a, 0);
+        return l_(type<result_type>(), f_, a, 0);
    }

 #endif
@@ -287,13 +287,13 @@
    template<class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9> result_type operator()(A1 & a1, A2 & a2, A3 & a3, A4 & a4, A5 & a5, A6 & a6, A7 & a7, A8 & a8, A9 & a9)
    {
        list9<A1 &, A2 &, A3 &, A4 &, A5 &, A6 &, A7 &, A8 &, A9 &> a(a1, a2, a3, a4, a5, a6, a7, a8, a9);
-        BOOST_BIND_RETURN l_(type<result_type>(), f_, a, 0);
+        return l_(type<result_type>(), f_, a, 0);
    }

    template<class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9> result_type operator()(A1 & a1, A2 & a2, A3 & a3, A4 & a4, A5 & a5, A6 & a6, A7 & a7, A8 & a8, A9 & a9) const
    {
        list9<A1 &, A2 &, A3 &, A4 &, A5 &, A6 &, A7 &, A8 &, A9 &> a(a1, a2, a3, a4, a5, a6, a7, a8, a9);
-        BOOST_BIND_RETURN l_(type<result_type>(), f_, a, 0);
+        return l_(type<result_type>(), f_, a, 0);
    }

 #if !defined(BOOST_NO_FUNCTION_TEMPLATE_ORDERING) \
@@ -302,25 +302,25 @@
    template<class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9> result_type operator()(A1 const & a1, A2 const & a2, A3 const & a3, A4 const & a4, A5 const & a5, A6 const & a6, A7 const & a7, A8 const & a8, A9 const & a9)
    {
        list9<A1 const &, A2 const &, A3 const &, A4 const &, A5 const &, A6 const &, A7 const &, A8 const &, A9 const &> a(a1, a2, a3, a4, a5, a6, a7, a8, a9);
-        BOOST_BIND_RETURN l_(type<result_type>(), f_, a, 0);
+        return l_(type<result_type>(), f_, a, 0);
    }

    template<class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9> result_type operator()(A1 const & a1, A2 const & a2, A3 const & a3, A4 const & a4, A5 const & a5, A6 const & a6, A7 const & a7, A8 const & a8, A9 const & a9) const
    {
        list9<A1 const &, A2 const &, A3 const &, A4 const &, A5 const &, A6 const &, A7 const &, A8 const &, A9 const &> a(a1, a2, a3, a4, a5, a6, a7, a8, a9);
-        BOOST_BIND_RETURN l_(type<result_type>(), f_, a, 0);
+        return l_(type<result_type>(), f_, a, 0);
    }

 #endif

    template<class A> result_type eval(A & a)
    {
-        BOOST_BIND_RETURN l_(type<result_type>(), f_, a, 0);
+        return l_(type<result_type>(), f_, a, 0);
    }

    template<class A> result_type eval(A & a) const
    {
-        BOOST_BIND_RETURN l_(type<result_type>(), f_, a, 0);
+        return l_(type<result_type>(), f_, a, 0);
    }

    template<class V> void accept(V & v) const
--- a/include/boost/bind/detail/is_same.hpp
+++ b/include/boost/bind/detail/is_same.hpp
@@ -0,0 +1,36 @@
+#ifndef BOOST_BIND_DETAIL_IS_SAME_HPP_INCLUDED
+#define BOOST_BIND_DETAIL_IS_SAME_HPP_INCLUDED
+
+// is_same<T1,T2>::value is true when T1 == T2
+//
+// Copyright 2014 Peter Dimov
+//
+// Distributed under the Boost Software License, Version 1.0.
+// See accompanying file LICENSE_1_0.txt or copy at
+// http://www.boost.org/LICENSE_1_0.txt
+
+#include <boost/config.hpp>
+
+#if defined(BOOST_HAS_PRAGMA_ONCE)
+# pragma once
+#endif
+
+namespace boost
+{
+namespace _bi
+{
+
+template< class T1, class T2 > struct is_same
+{
+    BOOST_STATIC_CONSTANT( bool, value = false );
+};
+
+template< class T > struct is_same< T, T >
+{
+    BOOST_STATIC_CONSTANT( bool, value = true );
+};
+
+} // namespace _bi
+} // namespace boost
+
+#endif // #ifndef BOOST_BIND_DETAIL_IS_SAME_HPP_INCLUDED
--- a/include/boost/bind/detail/requires_cxx11.hpp
+++ b/include/boost/bind/detail/requires_cxx11.hpp
@@ -0,0 +1,22 @@
+#ifndef BOOST_BIND_DETAIL_REQUIRES_CXX11_HPP_INCLUDED
+#define BOOST_BIND_DETAIL_REQUIRES_CXX11_HPP_INCLUDED
+
+// Copyright 2023 Peter Dimov
+// Distributed under the Boost Software License, Version 1.0.
+// https://www.boost.org/LICENSE_1_0.txt
+
+#include <boost/config.hpp>
+#include <boost/config/pragma_message.hpp>
+
+#if defined(BOOST_NO_CXX11_VARIADIC_TEMPLATES) || \
+    defined(BOOST_NO_CXX11_RVALUE_REFERENCES) || \
+    defined(BOOST_NO_CXX11_DECLTYPE) || \
+    defined(BOOST_NO_CXX11_CONSTEXPR) || \
+    defined(BOOST_NO_CXX11_NOEXCEPT) || \
+    defined(BOOST_NO_CXX11_HDR_FUNCTIONAL)
+
+BOOST_PRAGMA_MESSAGE("C++03 support was deprecated in Boost.Bind 1.82 and will be removed in Boost.Bind 1.85.")
+
+#endif
+
+#endif // #ifndef BOOST_BIND_DETAIL_REQUIRES_CXX11_HPP_INCLUDED
--- a/include/boost/bind/detail/result_traits.hpp
+++ b/include/boost/bind/detail/result_traits.hpp
@@ -21,7 +21,10 @@
 //  See http://www.boost.org/libs/bind/bind.html for documentation.
 //

-#if defined(_MSVC_LANG) && _MSVC_LANG >= 17
+#include <boost/config.hpp>
+#include <boost/core/ref.hpp>
+
+#if BOOST_CXX_VERSION >= 201700L
 #include <functional>
 #endif

@@ -48,7 +51,7 @@ template<class F> struct result_traits< unspecified, reference_wrapper<F> >
    typedef typename F::result_type type;
 };

-#if defined(_MSVC_LANG) && _MSVC_LANG >= 17
+#if BOOST_CXX_VERSION >= 201700L

 template<class T> struct result_traits< unspecified, std::plus<T> >
 {
@@ -140,6 +143,12 @@ template<class T> struct result_traits< unspecified, std::bit_xor<T> >
    typedef T type;
 };

+#if defined(BOOST_LIBSTDCXX_VERSION) && BOOST_LIBSTDCXX_VERSION < 40900
+
+// libstdc++ 4.8 and below don't have std::bit_not
+
+#else
+
 template<class T> struct result_traits< unspecified, std::bit_not<T> >
 {
    typedef T type;
@@ -147,6 +156,8 @@ template<class T> struct result_traits< unspecified, std::bit_not<T> >

 #endif

+#endif
+
 } // namespace _bi

 } // namespace boost
--- a/include/boost/bind/mem_fn.hpp
+++ b/include/boost/bind/mem_fn.hpp
@@ -21,194 +21,17 @@
 //  See http://www.boost.org/libs/bind/mem_fn.html for documentation.
 //

-#include <boost/config.hpp>
+#include <boost/bind/detail/requires_cxx11.hpp>
 #include <boost/get_pointer.hpp>
-#include <boost/detail/workaround.hpp>
+#include <boost/config.hpp>
+#include <boost/config/workaround.hpp>

 namespace boost
 {

-#if defined(BOOST_NO_VOID_RETURNS)
-
-#define BOOST_MEM_FN_CLASS_F , class F
-#define BOOST_MEM_FN_TYPEDEF(X)
-
-namespace _mfi // mem_fun_impl
-{
-
-template<class V> struct mf
-{
-
-#define BOOST_MEM_FN_RETURN return
-
-#define BOOST_MEM_FN_NAME(X) inner_##X
-#define BOOST_MEM_FN_CC
-
-#include <boost/bind/mem_fn_template.hpp>
-
-#undef BOOST_MEM_FN_CC
-#undef BOOST_MEM_FN_NAME
-
-#if defined(BOOST_MEM_FN_ENABLE_CDECL) && !defined(_M_X64)
-
-#define BOOST_MEM_FN_NAME(X) inner_##X##_cdecl
-#define BOOST_MEM_FN_CC __cdecl
-
-#include <boost/bind/mem_fn_template.hpp>
-
-#undef BOOST_MEM_FN_CC
-#undef BOOST_MEM_FN_NAME
-
-#endif
-
-#if defined(BOOST_MEM_FN_ENABLE_STDCALL) && !defined(_M_X64)
-
-#define BOOST_MEM_FN_NAME(X) inner_##X##_stdcall
-#define BOOST_MEM_FN_CC __stdcall
-
-#include <boost/bind/mem_fn_template.hpp>
-
-#undef BOOST_MEM_FN_CC
-#undef BOOST_MEM_FN_NAME
-
-#endif
-
-#if defined(BOOST_MEM_FN_ENABLE_FASTCALL) && !defined(_M_X64)
-
-#define BOOST_MEM_FN_NAME(X) inner_##X##_fastcall
-#define BOOST_MEM_FN_CC __fastcall
-
-#include <boost/bind/mem_fn_template.hpp>
-
-#undef BOOST_MEM_FN_CC
-#undef BOOST_MEM_FN_NAME
-
-#endif
-
-#undef BOOST_MEM_FN_RETURN
-
-}; // struct mf<V>
-
-template<> struct mf<void>
-{
-
-#define BOOST_MEM_FN_RETURN
-
-#define BOOST_MEM_FN_NAME(X) inner_##X
-#define BOOST_MEM_FN_CC
-
-#include <boost/bind/mem_fn_template.hpp>
-
-#undef BOOST_MEM_FN_CC
-#undef BOOST_MEM_FN_NAME
-
-#if defined(BOOST_MEM_FN_ENABLE_CDECL) && !defined(_M_X64)
-
-#define BOOST_MEM_FN_NAME(X) inner_##X##_cdecl
-#define BOOST_MEM_FN_CC __cdecl
-
-#include <boost/bind/mem_fn_template.hpp>
-
-#undef BOOST_MEM_FN_CC
-#undef BOOST_MEM_FN_NAME
-
-#endif
-
-#ifdef BOOST_MEM_FN_ENABLE_STDCALL
-
-#define BOOST_MEM_FN_NAME(X) inner_##X##_stdcall
-#define BOOST_MEM_FN_CC __stdcall
-
-#include <boost/bind/mem_fn_template.hpp>
-
-#undef BOOST_MEM_FN_CC
-#undef BOOST_MEM_FN_NAME
-
-#endif
-
-#ifdef BOOST_MEM_FN_ENABLE_FASTCALL
-
-#define BOOST_MEM_FN_NAME(X) inner_##X##_fastcall
-#define BOOST_MEM_FN_CC __fastcall
-
-#include <boost/bind/mem_fn_template.hpp>
-
-#undef BOOST_MEM_FN_CC
-#undef BOOST_MEM_FN_NAME
-
-#endif
-
-#undef BOOST_MEM_FN_RETURN
-
-}; // struct mf<void>
-
-#undef BOOST_MEM_FN_CLASS_F
-#undef BOOST_MEM_FN_TYPEDEF_F
-
-#define BOOST_MEM_FN_NAME(X) X
-#define BOOST_MEM_FN_NAME2(X) inner_##X
-#define BOOST_MEM_FN_CC
-
-#include <boost/bind/mem_fn_vw.hpp>
-
-#undef BOOST_MEM_FN_NAME
-#undef BOOST_MEM_FN_NAME2
-#undef BOOST_MEM_FN_CC
-
-#if defined(BOOST_MEM_FN_ENABLE_CDECL) && !defined(_M_X64)
-
-#define BOOST_MEM_FN_NAME(X) X##_cdecl
-#define BOOST_MEM_FN_NAME2(X) inner_##X##_cdecl
-#define BOOST_MEM_FN_CC __cdecl
-
-#include <boost/bind/mem_fn_vw.hpp>
-
-#undef BOOST_MEM_FN_NAME
-#undef BOOST_MEM_FN_NAME2
-#undef BOOST_MEM_FN_CC
-
-#endif
-
-#ifdef BOOST_MEM_FN_ENABLE_STDCALL
-
-#define BOOST_MEM_FN_NAME(X) X##_stdcall
-#define BOOST_MEM_FN_NAME2(X) inner_##X##_stdcall
-#define BOOST_MEM_FN_CC __stdcall
-
-#include <boost/bind/mem_fn_vw.hpp>
-
-#undef BOOST_MEM_FN_NAME
-#undef BOOST_MEM_FN_NAME2
-#undef BOOST_MEM_FN_CC
-
-#endif
-
-#ifdef BOOST_MEM_FN_ENABLE_FASTCALL
-
-#define BOOST_MEM_FN_NAME(X) X##_fastcall
-#define BOOST_MEM_FN_NAME2(X) inner_##X##_fastcall
-#define BOOST_MEM_FN_CC __fastcall
-
-#include <boost/bind/mem_fn_vw.hpp>
-
-#undef BOOST_MEM_FN_NAME
-#undef BOOST_MEM_FN_NAME2
-#undef BOOST_MEM_FN_CC
-
-#endif
-
-} // namespace _mfi
-
-#else // #ifdef BOOST_NO_VOID_RETURNS
-
-#define BOOST_MEM_FN_CLASS_F
-#define BOOST_MEM_FN_TYPEDEF(X) typedef X;
-
 namespace _mfi
 {

-#define BOOST_MEM_FN_RETURN return
-
 #define BOOST_MEM_FN_NAME(X) X
 #define BOOST_MEM_FN_CC

@@ -253,14 +76,9 @@ namespace _mfi

 #endif

-#undef BOOST_MEM_FN_RETURN
-
 } // namespace _mfi

-#undef BOOST_MEM_FN_CLASS_F
-#undef BOOST_MEM_FN_TYPEDEF
-
-#endif // #ifdef BOOST_NO_VOID_RETURNS
+//

 #define BOOST_MEM_FN_NAME(X) X
 #define BOOST_MEM_FN_CC
--- a/include/boost/bind/mem_fn_template.hpp
+++ b/include/boost/bind/mem_fn_template.hpp
@@ -18,7 +18,7 @@

 // mf0

-template<class R, class T BOOST_MEM_FN_CLASS_F> class BOOST_MEM_FN_NAME(mf0)
+template<class R, class T> class BOOST_MEM_FN_NAME(mf0)
 {
 public:

@@ -27,17 +27,17 @@ public:

 private:
    
-    BOOST_MEM_FN_TYPEDEF(R (BOOST_MEM_FN_CC T::*F) ())
+    typedef R (BOOST_MEM_FN_CC T::*F) ();
    F f_;

    template<class U> R call(U & u, T const *) const
    {
-        BOOST_MEM_FN_RETURN (u.*f_)();
+        return (u.*f_)();
    }

    template<class U> R call(U & u, void const *) const
    {
-        BOOST_MEM_FN_RETURN (get_pointer(u)->*f_)();
+        return (get_pointer(u)->*f_)();
    }

 public:
@@ -46,13 +46,13 @@ public:

    R operator()(T * p) const
    {
-        BOOST_MEM_FN_RETURN (p->*f_)();
+        return (p->*f_)();
    }

    template<class U> R operator()(U & u) const
    {
        U const * p = 0;
-        BOOST_MEM_FN_RETURN call(u, p);
+        return call(u, p);
    }

 #ifdef BOOST_MEM_FN_ENABLE_CONST_OVERLOADS
@@ -60,14 +60,14 @@ public:
    template<class U> R operator()(U const & u) const
    {
        U const * p = 0;
-        BOOST_MEM_FN_RETURN call(u, p);
+        return call(u, p);
    }

 #endif

    R operator()(T & t) const
    {
-        BOOST_MEM_FN_RETURN (t.*f_)();
+        return (t.*f_)();
    }

    bool operator==(BOOST_MEM_FN_NAME(mf0) const & rhs) const
@@ -83,7 +83,7 @@ public:

 // cmf0

-template<class R, class T BOOST_MEM_FN_CLASS_F> class BOOST_MEM_FN_NAME(cmf0)
+template<class R, class T> class BOOST_MEM_FN_NAME(cmf0)
 {
 public:

@@ -92,17 +92,17 @@ public:

 private:
    
-    BOOST_MEM_FN_TYPEDEF(R (BOOST_MEM_FN_CC T::*F) () const)
+    typedef R (BOOST_MEM_FN_CC T::*F) () const;
    F f_;

    template<class U> R call(U & u, T const *) const
    {
-        BOOST_MEM_FN_RETURN (u.*f_)();
+        return (u.*f_)();
    }

    template<class U> R call(U & u, void const *) const
    {
-        BOOST_MEM_FN_RETURN (get_pointer(u)->*f_)();
+        return (get_pointer(u)->*f_)();
    }

 public:
@@ -112,12 +112,12 @@ public:
    template<class U> R operator()(U const & u) const
    {
        U const * p = 0;
-        BOOST_MEM_FN_RETURN call(u, p);
+        return call(u, p);
    }

    R operator()(T const & t) const
    {
-        BOOST_MEM_FN_RETURN (t.*f_)();
+        return (t.*f_)();
    }

    bool operator==(BOOST_MEM_FN_NAME(cmf0) const & rhs) const
@@ -133,7 +133,7 @@ public:

 // mf1

-template<class R, class T, class A1 BOOST_MEM_FN_CLASS_F> class BOOST_MEM_FN_NAME(mf1)
+template<class R, class T, class A1> class BOOST_MEM_FN_NAME(mf1)
 {
 public:

@@ -143,17 +143,17 @@ public:

 private:
    
-    BOOST_MEM_FN_TYPEDEF(R (BOOST_MEM_FN_CC T::*F) (A1))
+    typedef R (BOOST_MEM_FN_CC T::*F) (A1);
    F f_;

    template<class U, class B1> R call(U & u, T const *, B1 & b1) const
    {
-        BOOST_MEM_FN_RETURN (u.*f_)(b1);
+        return (u.*f_)(b1);
    }

    template<class U, class B1> R call(U & u, void const *, B1 & b1) const
    {
-        BOOST_MEM_FN_RETURN (get_pointer(u)->*f_)(b1);
+        return (get_pointer(u)->*f_)(b1);
    }

 public:
@@ -162,13 +162,13 @@ public:

    R operator()(T * p, A1 a1) const
    {
-        BOOST_MEM_FN_RETURN (p->*f_)(a1);
+        return (p->*f_)(a1);
    }

    template<class U> R operator()(U & u, A1 a1) const
    {
        U const * p = 0;
-        BOOST_MEM_FN_RETURN call(u, p, a1);
+        return call(u, p, a1);
    }

 #ifdef BOOST_MEM_FN_ENABLE_CONST_OVERLOADS
@@ -176,14 +176,14 @@ public:
    template<class U> R operator()(U const & u, A1 a1) const
    {
        U const * p = 0;
-        BOOST_MEM_FN_RETURN call(u, p, a1);
+        return call(u, p, a1);
    }

 #endif

    R operator()(T & t, A1 a1) const
    {
-        BOOST_MEM_FN_RETURN (t.*f_)(a1);
+        return (t.*f_)(a1);
    }

    bool operator==(BOOST_MEM_FN_NAME(mf1) const & rhs) const
@@ -199,7 +199,7 @@ public:

 // cmf1

-template<class R, class T, class A1 BOOST_MEM_FN_CLASS_F> class BOOST_MEM_FN_NAME(cmf1)
+template<class R, class T, class A1> class BOOST_MEM_FN_NAME(cmf1)
 {
 public:

@@ -209,17 +209,17 @@ public:

 private:
    
-    BOOST_MEM_FN_TYPEDEF(R (BOOST_MEM_FN_CC T::*F) (A1) const)
+    typedef R (BOOST_MEM_FN_CC T::*F) (A1) const;
    F f_;

    template<class U, class B1> R call(U & u, T const *, B1 & b1) const
    {
-        BOOST_MEM_FN_RETURN (u.*f_)(b1);
+        return (u.*f_)(b1);
    }

    template<class U, class B1> R call(U & u, void const *, B1 & b1) const
    {
-        BOOST_MEM_FN_RETURN (get_pointer(u)->*f_)(b1);
+        return (get_pointer(u)->*f_)(b1);
    }

 public:
@@ -229,12 +229,12 @@ public:
    template<class U> R operator()(U const & u, A1 a1) const
    {
        U const * p = 0;
-        BOOST_MEM_FN_RETURN call(u, p, a1);
+        return call(u, p, a1);
    }

    R operator()(T const & t, A1 a1) const
    {
-        BOOST_MEM_FN_RETURN (t.*f_)(a1);
+        return (t.*f_)(a1);
    }

    bool operator==(BOOST_MEM_FN_NAME(cmf1) const & rhs) const
@@ -250,7 +250,7 @@ public:

 // mf2

-template<class R, class T, class A1, class A2 BOOST_MEM_FN_CLASS_F> class BOOST_MEM_FN_NAME(mf2)
+template<class R, class T, class A1, class A2> class BOOST_MEM_FN_NAME(mf2)
 {
 public:

@@ -258,17 +258,17 @@ public:

 private:
    
-    BOOST_MEM_FN_TYPEDEF(R (BOOST_MEM_FN_CC T::*F) (A1, A2))
+    typedef R (BOOST_MEM_FN_CC T::*F) (A1, A2);
    F f_;

    template<class U, class B1, class B2> R call(U & u, T const *, B1 & b1, B2 & b2) const
    {
-        BOOST_MEM_FN_RETURN (u.*f_)(b1, b2);
+        return (u.*f_)(b1, b2);
    }

    template<class U, class B1, class B2> R call(U & u, void const *, B1 & b1, B2 & b2) const
    {
-        BOOST_MEM_FN_RETURN (get_pointer(u)->*f_)(b1, b2);
+        return (get_pointer(u)->*f_)(b1, b2);
    }

 public:
@@ -277,13 +277,13 @@ public:

    R operator()(T * p, A1 a1, A2 a2) const
    {
-        BOOST_MEM_FN_RETURN (p->*f_)(a1, a2);
+        return (p->*f_)(a1, a2);
    }

    template<class U> R operator()(U & u, A1 a1, A2 a2) const
    {
        U const * p = 0;
-        BOOST_MEM_FN_RETURN call(u, p, a1, a2);
+        return call(u, p, a1, a2);
    }

 #ifdef BOOST_MEM_FN_ENABLE_CONST_OVERLOADS
@@ -291,14 +291,14 @@ public:
    template<class U> R operator()(U const & u, A1 a1, A2 a2) const
    {
        U const * p = 0;
-        BOOST_MEM_FN_RETURN call(u, p, a1, a2);
+        return call(u, p, a1, a2);
    }

 #endif

    R operator()(T & t, A1 a1, A2 a2) const
    {
-        BOOST_MEM_FN_RETURN (t.*f_)(a1, a2);
+        return (t.*f_)(a1, a2);
    }

    bool operator==(BOOST_MEM_FN_NAME(mf2) const & rhs) const
@@ -314,7 +314,7 @@ public:

 // cmf2

-template<class R, class T, class A1, class A2 BOOST_MEM_FN_CLASS_F> class BOOST_MEM_FN_NAME(cmf2)
+template<class R, class T, class A1, class A2> class BOOST_MEM_FN_NAME(cmf2)
 {
 public:

@@ -322,17 +322,17 @@ public:

 private:
    
-    BOOST_MEM_FN_TYPEDEF(R (BOOST_MEM_FN_CC T::*F) (A1, A2) const)
+    typedef R (BOOST_MEM_FN_CC T::*F) (A1, A2) const;
    F f_;

    template<class U, class B1, class B2> R call(U & u, T const *, B1 & b1, B2 & b2) const
    {
-        BOOST_MEM_FN_RETURN (u.*f_)(b1, b2);
+        return (u.*f_)(b1, b2);
    }

    template<class U, class B1, class B2> R call(U & u, void const *, B1 & b1, B2 & b2) const
    {
-        BOOST_MEM_FN_RETURN (get_pointer(u)->*f_)(b1, b2);
+        return (get_pointer(u)->*f_)(b1, b2);
    }

 public:
@@ -342,12 +342,12 @@ public:
    template<class U> R operator()(U const & u, A1 a1, A2 a2) const
    {
        U const * p = 0;
-        BOOST_MEM_FN_RETURN call(u, p, a1, a2);
+        return call(u, p, a1, a2);
    }

    R operator()(T const & t, A1 a1, A2 a2) const
    {
-        BOOST_MEM_FN_RETURN (t.*f_)(a1, a2);
+        return (t.*f_)(a1, a2);
    }

    bool operator==(BOOST_MEM_FN_NAME(cmf2) const & rhs) const
@@ -363,7 +363,7 @@ public:

 // mf3

-template<class R, class T, class A1, class A2, class A3 BOOST_MEM_FN_CLASS_F> class BOOST_MEM_FN_NAME(mf3)
+template<class R, class T, class A1, class A2, class A3> class BOOST_MEM_FN_NAME(mf3)
 {
 public:

@@ -371,17 +371,17 @@ public:

 private:
    
-    BOOST_MEM_FN_TYPEDEF(R (BOOST_MEM_FN_CC T::*F) (A1, A2, A3))
+    typedef R (BOOST_MEM_FN_CC T::*F) (A1, A2, A3);
    F f_;

    template<class U, class B1, class B2, class B3> R call(U & u, T const *, B1 & b1, B2 & b2, B3 & b3) const
    {
-        BOOST_MEM_FN_RETURN (u.*f_)(b1, b2, b3);
+        return (u.*f_)(b1, b2, b3);
    }

    template<class U, class B1, class B2, class B3> R call(U & u, void const *, B1 & b1, B2 & b2, B3 & b3) const
    {
-        BOOST_MEM_FN_RETURN (get_pointer(u)->*f_)(b1, b2, b3);
+        return (get_pointer(u)->*f_)(b1, b2, b3);
    }

 public:
@@ -390,13 +390,13 @@ public:

    R operator()(T * p, A1 a1, A2 a2, A3 a3) const
    {
-        BOOST_MEM_FN_RETURN (p->*f_)(a1, a2, a3);
+        return (p->*f_)(a1, a2, a3);
    }

    template<class U> R operator()(U & u, A1 a1, A2 a2, A3 a3) const
    {
        U const * p = 0;
-        BOOST_MEM_FN_RETURN call(u, p, a1, a2, a3);
+        return call(u, p, a1, a2, a3);
    }

 #ifdef BOOST_MEM_FN_ENABLE_CONST_OVERLOADS
@@ -404,14 +404,14 @@ public:
    template<class U> R operator()(U const & u, A1 a1, A2 a2, A3 a3) const
    {
        U const * p = 0;
-        BOOST_MEM_FN_RETURN call(u, p, a1, a2, a3);
+        return call(u, p, a1, a2, a3);
    }

 #endif

    R operator()(T & t, A1 a1, A2 a2, A3 a3) const
    {
-        BOOST_MEM_FN_RETURN (t.*f_)(a1, a2, a3);
+        return (t.*f_)(a1, a2, a3);
    }

    bool operator==(BOOST_MEM_FN_NAME(mf3) const & rhs) const
@@ -427,7 +427,7 @@ public:

 // cmf3

-template<class R, class T, class A1, class A2, class A3 BOOST_MEM_FN_CLASS_F> class BOOST_MEM_FN_NAME(cmf3)
+template<class R, class T, class A1, class A2, class A3> class BOOST_MEM_FN_NAME(cmf3)
 {
 public:

@@ -435,17 +435,17 @@ public:

 private:

-    BOOST_MEM_FN_TYPEDEF(R (BOOST_MEM_FN_CC T::*F) (A1, A2, A3) const)
+    typedef R (BOOST_MEM_FN_CC T::*F) (A1, A2, A3) const;
    F f_;

    template<class U, class B1, class B2, class B3> R call(U & u, T const *, B1 & b1, B2 & b2, B3 & b3) const
    {
-        BOOST_MEM_FN_RETURN (u.*f_)(b1, b2, b3);
+        return (u.*f_)(b1, b2, b3);
    }

    template<class U, class B1, class B2, class B3> R call(U & u, void const *, B1 & b1, B2 & b2, B3 & b3) const
    {
-        BOOST_MEM_FN_RETURN (get_pointer(u)->*f_)(b1, b2, b3);
+        return (get_pointer(u)->*f_)(b1, b2, b3);
    }

 public:
@@ -455,12 +455,12 @@ public:
    template<class U> R operator()(U const & u, A1 a1, A2 a2, A3 a3) const
    {
        U const * p = 0;
-        BOOST_MEM_FN_RETURN call(u, p, a1, a2, a3);
+        return call(u, p, a1, a2, a3);
    }

    R operator()(T const & t, A1 a1, A2 a2, A3 a3) const
    {
-        BOOST_MEM_FN_RETURN (t.*f_)(a1, a2, a3);
+        return (t.*f_)(a1, a2, a3);
    }

    bool operator==(BOOST_MEM_FN_NAME(cmf3) const & rhs) const
@@ -476,7 +476,7 @@ public:

 // mf4

-template<class R, class T, class A1, class A2, class A3, class A4 BOOST_MEM_FN_CLASS_F> class BOOST_MEM_FN_NAME(mf4)
+template<class R, class T, class A1, class A2, class A3, class A4> class BOOST_MEM_FN_NAME(mf4)
 {
 public:

@@ -484,17 +484,17 @@ public:

 private:
    
-    BOOST_MEM_FN_TYPEDEF(R (BOOST_MEM_FN_CC T::*F) (A1, A2, A3, A4))
+    typedef R (BOOST_MEM_FN_CC T::*F) (A1, A2, A3, A4);
    F f_;

    template<class U, class B1, class B2, class B3, class B4> R call(U & u, T const *, B1 & b1, B2 & b2, B3 & b3, B4 & b4) const
    {
-        BOOST_MEM_FN_RETURN (u.*f_)(b1, b2, b3, b4);
+        return (u.*f_)(b1, b2, b3, b4);
    }

    template<class U, class B1, class B2, class B3, class B4> R call(U & u, void const *, B1 & b1, B2 & b2, B3 & b3, B4 & b4) const
    {
-        BOOST_MEM_FN_RETURN (get_pointer(u)->*f_)(b1, b2, b3, b4);
+        return (get_pointer(u)->*f_)(b1, b2, b3, b4);
    }

 public:
@@ -503,13 +503,13 @@ public:

    R operator()(T * p, A1 a1, A2 a2, A3 a3, A4 a4) const
    {
-        BOOST_MEM_FN_RETURN (p->*f_)(a1, a2, a3, a4);
+        return (p->*f_)(a1, a2, a3, a4);
    }

    template<class U> R operator()(U & u, A1 a1, A2 a2, A3 a3, A4 a4) const
    {
        U const * p = 0;
-        BOOST_MEM_FN_RETURN call(u, p, a1, a2, a3, a4);
+        return call(u, p, a1, a2, a3, a4);
    }

 #ifdef BOOST_MEM_FN_ENABLE_CONST_OVERLOADS
@@ -517,14 +517,14 @@ public:
    template<class U> R operator()(U const & u, A1 a1, A2 a2, A3 a3, A4 a4) const
    {
        U const * p = 0;
-        BOOST_MEM_FN_RETURN call(u, p, a1, a2, a3, a4);
+        return call(u, p, a1, a2, a3, a4);
    }

 #endif

    R operator()(T & t, A1 a1, A2 a2, A3 a3, A4 a4) const
    {
-        BOOST_MEM_FN_RETURN (t.*f_)(a1, a2, a3, a4);
+        return (t.*f_)(a1, a2, a3, a4);
    }

    bool operator==(BOOST_MEM_FN_NAME(mf4) const & rhs) const
@@ -540,7 +540,7 @@ public:

 // cmf4

-template<class R, class T, class A1, class A2, class A3, class A4 BOOST_MEM_FN_CLASS_F> class BOOST_MEM_FN_NAME(cmf4)
+template<class R, class T, class A1, class A2, class A3, class A4> class BOOST_MEM_FN_NAME(cmf4)
 {
 public:

@@ -548,17 +548,17 @@ public:

 private:
    
-    BOOST_MEM_FN_TYPEDEF(R (BOOST_MEM_FN_CC T::*F) (A1, A2, A3, A4) const)
+    typedef R (BOOST_MEM_FN_CC T::*F) (A1, A2, A3, A4) const;
    F f_;

    template<class U, class B1, class B2, class B3, class B4> R call(U & u, T const *, B1 & b1, B2 & b2, B3 & b3, B4 & b4) const
    {
-        BOOST_MEM_FN_RETURN (u.*f_)(b1, b2, b3, b4);
+        return (u.*f_)(b1, b2, b3, b4);
    }

    template<class U, class B1, class B2, class B3, class B4> R call(U & u, void const *, B1 & b1, B2 & b2, B3 & b3, B4 & b4) const
    {
-        BOOST_MEM_FN_RETURN (get_pointer(u)->*f_)(b1, b2, b3, b4);
+        return (get_pointer(u)->*f_)(b1, b2, b3, b4);
    }

 public:
@@ -568,12 +568,12 @@ public:
    template<class U> R operator()(U const & u, A1 a1, A2 a2, A3 a3, A4 a4) const
    {
        U const * p = 0;
-        BOOST_MEM_FN_RETURN call(u, p, a1, a2, a3, a4);
+        return call(u, p, a1, a2, a3, a4);
    }

    R operator()(T const & t, A1 a1, A2 a2, A3 a3, A4 a4) const
    {
-        BOOST_MEM_FN_RETURN (t.*f_)(a1, a2, a3, a4);
+        return (t.*f_)(a1, a2, a3, a4);
    }

    bool operator==(BOOST_MEM_FN_NAME(cmf4) const & rhs) const
@@ -589,7 +589,7 @@ public:

 // mf5

-template<class R, class T, class A1, class A2, class A3, class A4, class A5 BOOST_MEM_FN_CLASS_F> class BOOST_MEM_FN_NAME(mf5)
+template<class R, class T, class A1, class A2, class A3, class A4, class A5> class BOOST_MEM_FN_NAME(mf5)
 {
 public:

@@ -597,17 +597,17 @@ public:

 private:
    
-    BOOST_MEM_FN_TYPEDEF(R (BOOST_MEM_FN_CC T::*F) (A1, A2, A3, A4, A5))
+    typedef R (BOOST_MEM_FN_CC T::*F) (A1, A2, A3, A4, A5);
    F f_;

    template<class U, class B1, class B2, class B3, class B4, class B5> R call(U & u, T const *, B1 & b1, B2 & b2, B3 & b3, B4 & b4, B5 & b5) const
    {
-        BOOST_MEM_FN_RETURN (u.*f_)(b1, b2, b3, b4, b5);
+        return (u.*f_)(b1, b2, b3, b4, b5);
    }

    template<class U, class B1, class B2, class B3, class B4, class B5> R call(U & u, void const *, B1 & b1, B2 & b2, B3 & b3, B4 & b4, B5 & b5) const
    {
-        BOOST_MEM_FN_RETURN (get_pointer(u)->*f_)(b1, b2, b3, b4, b5);
+        return (get_pointer(u)->*f_)(b1, b2, b3, b4, b5);
    }

 public:
@@ -616,13 +616,13 @@ public:

    R operator()(T * p, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5) const
    {
-        BOOST_MEM_FN_RETURN (p->*f_)(a1, a2, a3, a4, a5);
+        return (p->*f_)(a1, a2, a3, a4, a5);
    }

    template<class U> R operator()(U & u, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5) const
    {
        U const * p = 0;
-        BOOST_MEM_FN_RETURN call(u, p, a1, a2, a3, a4, a5);
+        return call(u, p, a1, a2, a3, a4, a5);
    }

 #ifdef BOOST_MEM_FN_ENABLE_CONST_OVERLOADS
@@ -630,14 +630,14 @@ public:
    template<class U> R operator()(U const & u, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5) const
    {
        U const * p = 0;
-        BOOST_MEM_FN_RETURN call(u, p, a1, a2, a3, a4, a5);
+        return call(u, p, a1, a2, a3, a4, a5);
    }

 #endif

    R operator()(T & t, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5) const
    {
-        BOOST_MEM_FN_RETURN (t.*f_)(a1, a2, a3, a4, a5);
+        return (t.*f_)(a1, a2, a3, a4, a5);
    }

    bool operator==(BOOST_MEM_FN_NAME(mf5) const & rhs) const
@@ -653,7 +653,7 @@ public:

 // cmf5

-template<class R, class T, class A1, class A2, class A3, class A4, class A5 BOOST_MEM_FN_CLASS_F> class BOOST_MEM_FN_NAME(cmf5)
+template<class R, class T, class A1, class A2, class A3, class A4, class A5> class BOOST_MEM_FN_NAME(cmf5)
 {
 public:

@@ -661,17 +661,17 @@ public:

 private:
    
-    BOOST_MEM_FN_TYPEDEF(R (BOOST_MEM_FN_CC T::*F) (A1, A2, A3, A4, A5) const)
+    typedef R (BOOST_MEM_FN_CC T::*F) (A1, A2, A3, A4, A5) const;
    F f_;

    template<class U, class B1, class B2, class B3, class B4, class B5> R call(U & u, T const *, B1 & b1, B2 & b2, B3 & b3, B4 & b4, B5 & b5) const
    {
-        BOOST_MEM_FN_RETURN (u.*f_)(b1, b2, b3, b4, b5);
+        return (u.*f_)(b1, b2, b3, b4, b5);
    }

    template<class U, class B1, class B2, class B3, class B4, class B5> R call(U & u, void const *, B1 & b1, B2 & b2, B3 & b3, B4 & b4, B5 & b5) const
    {
-        BOOST_MEM_FN_RETURN (get_pointer(u)->*f_)(b1, b2, b3, b4, b5);
+        return (get_pointer(u)->*f_)(b1, b2, b3, b4, b5);
    }

 public:
@@ -681,12 +681,12 @@ public:
    template<class U> R operator()(U const & u, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5) const
    {
        U const * p = 0;
-        BOOST_MEM_FN_RETURN call(u, p, a1, a2, a3, a4, a5);
+        return call(u, p, a1, a2, a3, a4, a5);
    }

    R operator()(T const & t, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5) const
    {
-        BOOST_MEM_FN_RETURN (t.*f_)(a1, a2, a3, a4, a5);
+        return (t.*f_)(a1, a2, a3, a4, a5);
    }

    bool operator==(BOOST_MEM_FN_NAME(cmf5) const & rhs) const
@@ -702,7 +702,7 @@ public:

 // mf6

-template<class R, class T, class A1, class A2, class A3, class A4, class A5, class A6 BOOST_MEM_FN_CLASS_F> class BOOST_MEM_FN_NAME(mf6)
+template<class R, class T, class A1, class A2, class A3, class A4, class A5, class A6> class BOOST_MEM_FN_NAME(mf6)
 {
 public:

@@ -710,17 +710,17 @@ public:

 private:

-    BOOST_MEM_FN_TYPEDEF(R (BOOST_MEM_FN_CC T::*F) (A1, A2, A3, A4, A5, A6))
+    typedef R (BOOST_MEM_FN_CC T::*F) (A1, A2, A3, A4, A5, A6);
    F f_;

    template<class U, class B1, class B2, class B3, class B4, class B5, class B6> R call(U & u, T const *, B1 & b1, B2 & b2, B3 & b3, B4 & b4, B5 & b5, B6 & b6) const
    {
-        BOOST_MEM_FN_RETURN (u.*f_)(b1, b2, b3, b4, b5, b6);
+        return (u.*f_)(b1, b2, b3, b4, b5, b6);
    }

    template<class U, class B1, class B2, class B3, class B4, class B5, class B6> R call(U & u, void const *, B1 & b1, B2 & b2, B3 & b3, B4 & b4, B5 & b5, B6 & b6) const
    {
-        BOOST_MEM_FN_RETURN (get_pointer(u)->*f_)(b1, b2, b3, b4, b5, b6);
+        return (get_pointer(u)->*f_)(b1, b2, b3, b4, b5, b6);
    }

 public:
@@ -729,13 +729,13 @@ public:

    R operator()(T * p, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6) const
    {
-        BOOST_MEM_FN_RETURN (p->*f_)(a1, a2, a3, a4, a5, a6);
+        return (p->*f_)(a1, a2, a3, a4, a5, a6);
    }

    template<class U> R operator()(U & u, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6) const
    {
        U const * p = 0;
-        BOOST_MEM_FN_RETURN call(u, p, a1, a2, a3, a4, a5, a6);
+        return call(u, p, a1, a2, a3, a4, a5, a6);
    }

 #ifdef BOOST_MEM_FN_ENABLE_CONST_OVERLOADS
@@ -743,14 +743,14 @@ public:
    template<class U> R operator()(U const & u, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6) const
    {
        U const * p = 0;
-        BOOST_MEM_FN_RETURN call(u, p, a1, a2, a3, a4, a5, a6);
+        return call(u, p, a1, a2, a3, a4, a5, a6);
    }

 #endif

    R operator()(T & t, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6) const
    {
-        BOOST_MEM_FN_RETURN (t.*f_)(a1, a2, a3, a4, a5, a6);
+        return (t.*f_)(a1, a2, a3, a4, a5, a6);
    }

    bool operator==(BOOST_MEM_FN_NAME(mf6) const & rhs) const
@@ -766,7 +766,7 @@ public:

 // cmf6

-template<class R, class T, class A1, class A2, class A3, class A4, class A5, class A6 BOOST_MEM_FN_CLASS_F> class BOOST_MEM_FN_NAME(cmf6)
+template<class R, class T, class A1, class A2, class A3, class A4, class A5, class A6> class BOOST_MEM_FN_NAME(cmf6)
 {
 public:

@@ -774,17 +774,17 @@ public:

 private:
    
-    BOOST_MEM_FN_TYPEDEF(R (BOOST_MEM_FN_CC T::*F) (A1, A2, A3, A4, A5, A6) const)
+    typedef R (BOOST_MEM_FN_CC T::*F) (A1, A2, A3, A4, A5, A6) const;
    F f_;

    template<class U, class B1, class B2, class B3, class B4, class B5, class B6> R call(U & u, T const *, B1 & b1, B2 & b2, B3 & b3, B4 & b4, B5 & b5, B6 & b6) const
    {
-        BOOST_MEM_FN_RETURN (u.*f_)(b1, b2, b3, b4, b5, b6);
+        return (u.*f_)(b1, b2, b3, b4, b5, b6);
    }

    template<class U, class B1, class B2, class B3, class B4, class B5, class B6> R call(U & u, void const *, B1 & b1, B2 & b2, B3 & b3, B4 & b4, B5 & b5, B6 & b6) const
    {
-        BOOST_MEM_FN_RETURN (get_pointer(u)->*f_)(b1, b2, b3, b4, b5, b6);
+        return (get_pointer(u)->*f_)(b1, b2, b3, b4, b5, b6);
    }

 public:
@@ -794,12 +794,12 @@ public:
    template<class U> R operator()(U const & u, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6) const
    {
        U const * p = 0;
-        BOOST_MEM_FN_RETURN call(u, p, a1, a2, a3, a4, a5, a6);
+        return call(u, p, a1, a2, a3, a4, a5, a6);
    }

    R operator()(T const & t, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6) const
    {
-        BOOST_MEM_FN_RETURN (t.*f_)(a1, a2, a3, a4, a5, a6);
+        return (t.*f_)(a1, a2, a3, a4, a5, a6);
    }

    bool operator==(BOOST_MEM_FN_NAME(cmf6) const & rhs) const
@@ -815,7 +815,7 @@ public:

 // mf7

-template<class R, class T, class A1, class A2, class A3, class A4, class A5, class A6, class A7 BOOST_MEM_FN_CLASS_F> class BOOST_MEM_FN_NAME(mf7)
+template<class R, class T, class A1, class A2, class A3, class A4, class A5, class A6, class A7> class BOOST_MEM_FN_NAME(mf7)
 {
 public:

@@ -823,17 +823,17 @@ public:

 private:
    
-    BOOST_MEM_FN_TYPEDEF(R (BOOST_MEM_FN_CC T::*F) (A1, A2, A3, A4, A5, A6, A7))
+    typedef R (BOOST_MEM_FN_CC T::*F) (A1, A2, A3, A4, A5, A6, A7);
    F f_;

    template<class U, class B1, class B2, class B3, class B4, class B5, class B6, class B7> R call(U & u, T const *, B1 & b1, B2 & b2, B3 & b3, B4 & b4, B5 & b5, B6 & b6, B7 & b7) const
    {
-        BOOST_MEM_FN_RETURN (u.*f_)(b1, b2, b3, b4, b5, b6, b7);
+        return (u.*f_)(b1, b2, b3, b4, b5, b6, b7);
    }

    template<class U, class B1, class B2, class B3, class B4, class B5, class B6, class B7> R call(U & u, void const *, B1 & b1, B2 & b2, B3 & b3, B4 & b4, B5 & b5, B6 & b6, B7 & b7) const
    {
-        BOOST_MEM_FN_RETURN (get_pointer(u)->*f_)(b1, b2, b3, b4, b5, b6, b7);
+        return (get_pointer(u)->*f_)(b1, b2, b3, b4, b5, b6, b7);
    }

 public:
@@ -842,13 +842,13 @@ public:

    R operator()(T * p, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7) const
    {
-        BOOST_MEM_FN_RETURN (p->*f_)(a1, a2, a3, a4, a5, a6, a7);
+        return (p->*f_)(a1, a2, a3, a4, a5, a6, a7);
    }

    template<class U> R operator()(U & u, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7) const
    {
        U const * p = 0;
-        BOOST_MEM_FN_RETURN call(u, p, a1, a2, a3, a4, a5, a6, a7);
+        return call(u, p, a1, a2, a3, a4, a5, a6, a7);
    }

 #ifdef BOOST_MEM_FN_ENABLE_CONST_OVERLOADS
@@ -856,14 +856,14 @@ public:
    template<class U> R operator()(U const & u, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7) const
    {
        U const * p = 0;
-        BOOST_MEM_FN_RETURN call(u, p, a1, a2, a3, a4, a5, a6, a7);
+        return call(u, p, a1, a2, a3, a4, a5, a6, a7);
    }

 #endif

    R operator()(T & t, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7) const
    {
-        BOOST_MEM_FN_RETURN (t.*f_)(a1, a2, a3, a4, a5, a6, a7);
+        return (t.*f_)(a1, a2, a3, a4, a5, a6, a7);
    }

    bool operator==(BOOST_MEM_FN_NAME(mf7) const & rhs) const
@@ -879,7 +879,7 @@ public:

 // cmf7

-template<class R, class T, class A1, class A2, class A3, class A4, class A5, class A6, class A7 BOOST_MEM_FN_CLASS_F> class BOOST_MEM_FN_NAME(cmf7)
+template<class R, class T, class A1, class A2, class A3, class A4, class A5, class A6, class A7> class BOOST_MEM_FN_NAME(cmf7)
 {
 public:

@@ -887,17 +887,17 @@ public:

 private:
    
-    BOOST_MEM_FN_TYPEDEF(R (BOOST_MEM_FN_CC T::*F) (A1, A2, A3, A4, A5, A6, A7) const)
+    typedef R (BOOST_MEM_FN_CC T::*F) (A1, A2, A3, A4, A5, A6, A7) const;
    F f_;

    template<class U, class B1, class B2, class B3, class B4, class B5, class B6, class B7> R call(U & u, T const *, B1 & b1, B2 & b2, B3 & b3, B4 & b4, B5 & b5, B6 & b6, B7 & b7) const
    {
-        BOOST_MEM_FN_RETURN (u.*f_)(b1, b2, b3, b4, b5, b6, b7);
+        return (u.*f_)(b1, b2, b3, b4, b5, b6, b7);
    }

    template<class U, class B1, class B2, class B3, class B4, class B5, class B6, class B7> R call(U & u, void const *, B1 & b1, B2 & b2, B3 & b3, B4 & b4, B5 & b5, B6 & b6, B7 & b7) const
    {
-        BOOST_MEM_FN_RETURN (get_pointer(u)->*f_)(b1, b2, b3, b4, b5, b6, b7);
+        return (get_pointer(u)->*f_)(b1, b2, b3, b4, b5, b6, b7);
    }

 public:
@@ -907,12 +907,12 @@ public:
    template<class U> R operator()(U const & u, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7) const
    {
        U const * p = 0;
-        BOOST_MEM_FN_RETURN call(u, p, a1, a2, a3, a4, a5, a6, a7);
+        return call(u, p, a1, a2, a3, a4, a5, a6, a7);
    }

    R operator()(T const & t, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7) const
    {
-        BOOST_MEM_FN_RETURN (t.*f_)(a1, a2, a3, a4, a5, a6, a7);
+        return (t.*f_)(a1, a2, a3, a4, a5, a6, a7);
    }

    bool operator==(BOOST_MEM_FN_NAME(cmf7) const & rhs) const
@@ -928,7 +928,7 @@ public:

 // mf8

-template<class R, class T, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8 BOOST_MEM_FN_CLASS_F> class BOOST_MEM_FN_NAME(mf8)
+template<class R, class T, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8> class BOOST_MEM_FN_NAME(mf8)
 {
 public:

@@ -936,17 +936,17 @@ public:

 private:
    
-    BOOST_MEM_FN_TYPEDEF(R (BOOST_MEM_FN_CC T::*F) (A1, A2, A3, A4, A5, A6, A7, A8))
+    typedef R (BOOST_MEM_FN_CC T::*F) (A1, A2, A3, A4, A5, A6, A7, A8);
    F f_;

    template<class U, class B1, class B2, class B3, class B4, class B5, class B6, class B7, class B8> R call(U & u, T const *, B1 & b1, B2 & b2, B3 & b3, B4 & b4, B5 & b5, B6 & b6, B7 & b7, B8 & b8) const
    {
-        BOOST_MEM_FN_RETURN (u.*f_)(b1, b2, b3, b4, b5, b6, b7, b8);
+        return (u.*f_)(b1, b2, b3, b4, b5, b6, b7, b8);
    }

    template<class U, class B1, class B2, class B3, class B4, class B5, class B6, class B7, class B8> R call(U & u, void const *, B1 & b1, B2 & b2, B3 & b3, B4 & b4, B5 & b5, B6 & b6, B7 & b7, B8 & b8) const
    {
-        BOOST_MEM_FN_RETURN (get_pointer(u)->*f_)(b1, b2, b3, b4, b5, b6, b7, b8);
+        return (get_pointer(u)->*f_)(b1, b2, b3, b4, b5, b6, b7, b8);
    }

 public:
@@ -955,13 +955,13 @@ public:

    R operator()(T * p, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8) const
    {
-        BOOST_MEM_FN_RETURN (p->*f_)(a1, a2, a3, a4, a5, a6, a7, a8);
+        return (p->*f_)(a1, a2, a3, a4, a5, a6, a7, a8);
    }

    template<class U> R operator()(U & u, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8) const
    {
        U const * p = 0;
-        BOOST_MEM_FN_RETURN call(u, p, a1, a2, a3, a4, a5, a6, a7, a8);
+        return call(u, p, a1, a2, a3, a4, a5, a6, a7, a8);
    }

 #ifdef BOOST_MEM_FN_ENABLE_CONST_OVERLOADS
@@ -969,14 +969,14 @@ public:
    template<class U> R operator()(U const & u, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8) const
    {
        U const * p = 0;
-        BOOST_MEM_FN_RETURN call(u, p, a1, a2, a3, a4, a5, a6, a7, a8);
+        return call(u, p, a1, a2, a3, a4, a5, a6, a7, a8);
    }

 #endif

    R operator()(T & t, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8) const
    {
-        BOOST_MEM_FN_RETURN (t.*f_)(a1, a2, a3, a4, a5, a6, a7, a8);
+        return (t.*f_)(a1, a2, a3, a4, a5, a6, a7, a8);
    }

    bool operator==(BOOST_MEM_FN_NAME(mf8) const & rhs) const
@@ -992,7 +992,7 @@ public:

 // cmf8

-template<class R, class T, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8 BOOST_MEM_FN_CLASS_F> class BOOST_MEM_FN_NAME(cmf8)
+template<class R, class T, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8> class BOOST_MEM_FN_NAME(cmf8)
 {
 public:

@@ -1000,17 +1000,17 @@ public:

 private:
    
-    BOOST_MEM_FN_TYPEDEF(R (BOOST_MEM_FN_CC T::*F) (A1, A2, A3, A4, A5, A6, A7, A8) const)
+    typedef R (BOOST_MEM_FN_CC T::*F) (A1, A2, A3, A4, A5, A6, A7, A8) const;
    F f_;

    template<class U, class B1, class B2, class B3, class B4, class B5, class B6, class B7, class B8> R call(U & u, T const *, B1 & b1, B2 & b2, B3 & b3, B4 & b4, B5 & b5, B6 & b6, B7 & b7, B8 & b8) const
    {
-        BOOST_MEM_FN_RETURN (u.*f_)(b1, b2, b3, b4, b5, b6, b7, b8);
+        return (u.*f_)(b1, b2, b3, b4, b5, b6, b7, b8);
    }

    template<class U, class B1, class B2, class B3, class B4, class B5, class B6, class B7, class B8> R call(U & u, void const *, B1 & b1, B2 & b2, B3 & b3, B4 & b4, B5 & b5, B6 & b6, B7 & b7, B8 & b8) const
    {
-        BOOST_MEM_FN_RETURN (get_pointer(u)->*f_)(b1, b2, b3, b4, b5, b6, b7, b8);
+        return (get_pointer(u)->*f_)(b1, b2, b3, b4, b5, b6, b7, b8);
    }

 public:
@@ -1019,18 +1019,18 @@ public:

    R operator()(T const * p, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8) const
    {
-        BOOST_MEM_FN_RETURN (p->*f_)(a1, a2, a3, a4, a5, a6, a7, a8);
+        return (p->*f_)(a1, a2, a3, a4, a5, a6, a7, a8);
    }

    template<class U> R operator()(U const & u, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8) const
    {
        U const * p = 0;
-        BOOST_MEM_FN_RETURN call(u, p, a1, a2, a3, a4, a5, a6, a7, a8);
+        return call(u, p, a1, a2, a3, a4, a5, a6, a7, a8);
    }

    R operator()(T const & t, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8) const
    {
-        BOOST_MEM_FN_RETURN (t.*f_)(a1, a2, a3, a4, a5, a6, a7, a8);
+        return (t.*f_)(a1, a2, a3, a4, a5, a6, a7, a8);
    }

    bool operator==(BOOST_MEM_FN_NAME(cmf8) const & rhs) const
--- a/include/boost/bind/mem_fn_vw.hpp
+++ b/include/boost/bind/mem_fn_vw.hpp
@@ -1,130 +0,0 @@
-//
-//  bind/mem_fn_vw.hpp - void return helper wrappers
-//
-//  Do not include this header directly
-//
-//  Copyright (c) 2001 Peter Dimov and Multi Media Ltd.
-//
-// Distributed under the Boost Software License, Version 1.0. (See
-// accompanying file LICENSE_1_0.txt or copy at
-// http://www.boost.org/LICENSE_1_0.txt)
-//
-//  See http://www.boost.org/libs/bind/mem_fn.html for documentation.
-//
-
-template<class R, class T> struct BOOST_MEM_FN_NAME(mf0): public mf<R>::BOOST_NESTED_TEMPLATE BOOST_MEM_FN_NAME2(mf0)<R, T, R (BOOST_MEM_FN_CC T::*) ()>
-{
-    typedef R (BOOST_MEM_FN_CC T::*F) ();
-    explicit BOOST_MEM_FN_NAME(mf0)(F f): mf<R>::BOOST_NESTED_TEMPLATE BOOST_MEM_FN_NAME2(mf0)<R, T, F>(f) {}
-};
-
-template<class R, class T> struct BOOST_MEM_FN_NAME(cmf0): public mf<R>::BOOST_NESTED_TEMPLATE BOOST_MEM_FN_NAME2(cmf0)<R, T, R (BOOST_MEM_FN_CC T::*) () const>
-{
-    typedef R (BOOST_MEM_FN_CC T::*F) () const;
-    explicit BOOST_MEM_FN_NAME(cmf0)(F f): mf<R>::BOOST_NESTED_TEMPLATE BOOST_MEM_FN_NAME2(cmf0)<R, T, F>(f) {}
-};
-
-
-template<class R, class T, class A1> struct BOOST_MEM_FN_NAME(mf1): public mf<R>::BOOST_NESTED_TEMPLATE BOOST_MEM_FN_NAME2(mf1)<R, T, A1, R (BOOST_MEM_FN_CC T::*) (A1)>
-{
-    typedef R (BOOST_MEM_FN_CC T::*F) (A1);
-    explicit BOOST_MEM_FN_NAME(mf1)(F f): mf<R>::BOOST_NESTED_TEMPLATE BOOST_MEM_FN_NAME2(mf1)<R, T, A1, F>(f) {}
-};
-
-template<class R, class T, class A1> struct BOOST_MEM_FN_NAME(cmf1): public mf<R>::BOOST_NESTED_TEMPLATE BOOST_MEM_FN_NAME2(cmf1)<R, T, A1, R (BOOST_MEM_FN_CC T::*) (A1) const>
-{
-    typedef R (BOOST_MEM_FN_CC T::*F) (A1) const;
-    explicit BOOST_MEM_FN_NAME(cmf1)(F f): mf<R>::BOOST_NESTED_TEMPLATE BOOST_MEM_FN_NAME2(cmf1)<R, T, A1, F>(f) {}
-};
-
-
-template<class R, class T, class A1, class A2> struct BOOST_MEM_FN_NAME(mf2): public mf<R>::BOOST_NESTED_TEMPLATE BOOST_MEM_FN_NAME2(mf2)<R, T, A1, A2, R (BOOST_MEM_FN_CC T::*) (A1, A2)>
-{
-    typedef R (BOOST_MEM_FN_CC T::*F) (A1, A2);
-    explicit BOOST_MEM_FN_NAME(mf2)(F f): mf<R>::BOOST_NESTED_TEMPLATE BOOST_MEM_FN_NAME2(mf2)<R, T, A1, A2, F>(f) {}
-};
-
-template<class R, class T, class A1, class A2> struct BOOST_MEM_FN_NAME(cmf2): public mf<R>::BOOST_NESTED_TEMPLATE BOOST_MEM_FN_NAME2(cmf2)<R, T, A1, A2, R (BOOST_MEM_FN_CC T::*) (A1, A2) const>
-{
-    typedef R (BOOST_MEM_FN_CC T::*F) (A1, A2) const;
-    explicit BOOST_MEM_FN_NAME(cmf2)(F f): mf<R>::BOOST_NESTED_TEMPLATE BOOST_MEM_FN_NAME2(cmf2)<R, T, A1, A2, F>(f) {}
-};
-
-
-template<class R, class T, class A1, class A2, class A3> struct BOOST_MEM_FN_NAME(mf3): public mf<R>::BOOST_NESTED_TEMPLATE BOOST_MEM_FN_NAME2(mf3)<R, T, A1, A2, A3, R (BOOST_MEM_FN_CC T::*) (A1, A2, A3)>
-{
-    typedef R (BOOST_MEM_FN_CC T::*F) (A1, A2, A3);
-    explicit BOOST_MEM_FN_NAME(mf3)(F f): mf<R>::BOOST_NESTED_TEMPLATE BOOST_MEM_FN_NAME2(mf3)<R, T, A1, A2, A3, F>(f) {}
-};
-
-template<class R, class T, class A1, class A2, class A3> struct BOOST_MEM_FN_NAME(cmf3): public mf<R>::BOOST_NESTED_TEMPLATE BOOST_MEM_FN_NAME2(cmf3)<R, T, A1, A2, A3, R (BOOST_MEM_FN_CC T::*) (A1, A2, A3) const>
-{
-    typedef R (BOOST_MEM_FN_CC T::*F) (A1, A2, A3) const;
-    explicit BOOST_MEM_FN_NAME(cmf3)(F f): mf<R>::BOOST_NESTED_TEMPLATE BOOST_MEM_FN_NAME2(cmf3)<R, T, A1, A2, A3, F>(f) {}
-};
-
-
-template<class R, class T, class A1, class A2, class A3, class A4> struct BOOST_MEM_FN_NAME(mf4): public mf<R>::BOOST_NESTED_TEMPLATE BOOST_MEM_FN_NAME2(mf4)<R, T, A1, A2, A3, A4, R (BOOST_MEM_FN_CC T::*) (A1, A2, A3, A4)>
-{
-    typedef R (BOOST_MEM_FN_CC T::*F) (A1, A2, A3, A4);
-    explicit BOOST_MEM_FN_NAME(mf4)(F f): mf<R>::BOOST_NESTED_TEMPLATE BOOST_MEM_FN_NAME2(mf4)<R, T, A1, A2, A3, A4, F>(f) {}
-};
-
-template<class R, class T, class A1, class A2, class A3, class A4> struct BOOST_MEM_FN_NAME(cmf4): public mf<R>::BOOST_NESTED_TEMPLATE BOOST_MEM_FN_NAME2(cmf4)<R, T, A1, A2, A3, A4, R (BOOST_MEM_FN_CC T::*) (A1, A2, A3, A4) const>
-{
-    typedef R (BOOST_MEM_FN_CC T::*F) (A1, A2, A3, A4) const;
-    explicit BOOST_MEM_FN_NAME(cmf4)(F f): mf<R>::BOOST_NESTED_TEMPLATE BOOST_MEM_FN_NAME2(cmf4)<R, T, A1, A2, A3, A4, F>(f) {}
-};
-
-
-template<class R, class T, class A1, class A2, class A3, class A4, class A5> struct BOOST_MEM_FN_NAME(mf5): public mf<R>::BOOST_NESTED_TEMPLATE BOOST_MEM_FN_NAME2(mf5)<R, T, A1, A2, A3, A4, A5, R (BOOST_MEM_FN_CC T::*) (A1, A2, A3, A4, A5)>
-{
-    typedef R (BOOST_MEM_FN_CC T::*F) (A1, A2, A3, A4, A5);
-    explicit BOOST_MEM_FN_NAME(mf5)(F f): mf<R>::BOOST_NESTED_TEMPLATE BOOST_MEM_FN_NAME2(mf5)<R, T, A1, A2, A3, A4, A5, F>(f) {}
-};
-
-template<class R, class T, class A1, class A2, class A3, class A4, class A5> struct BOOST_MEM_FN_NAME(cmf5): public mf<R>::BOOST_NESTED_TEMPLATE BOOST_MEM_FN_NAME2(cmf5)<R, T, A1, A2, A3, A4, A5, R (BOOST_MEM_FN_CC T::*) (A1, A2, A3, A4, A5) const>
-{
-    typedef R (BOOST_MEM_FN_CC T::*F) (A1, A2, A3, A4, A5) const;
-    explicit BOOST_MEM_FN_NAME(cmf5)(F f): mf<R>::BOOST_NESTED_TEMPLATE BOOST_MEM_FN_NAME2(cmf5)<R, T, A1, A2, A3, A4, A5, F>(f) {}
-};
-
-
-template<class R, class T, class A1, class A2, class A3, class A4, class A5, class A6> struct BOOST_MEM_FN_NAME(mf6): public mf<R>::BOOST_NESTED_TEMPLATE BOOST_MEM_FN_NAME2(mf6)<R, T, A1, A2, A3, A4, A5, A6, R (BOOST_MEM_FN_CC T::*) (A1, A2, A3, A4, A5, A6)>
-{
-    typedef R (BOOST_MEM_FN_CC T::*F) (A1, A2, A3, A4, A5, A6);
-    explicit BOOST_MEM_FN_NAME(mf6)(F f): mf<R>::BOOST_NESTED_TEMPLATE BOOST_MEM_FN_NAME2(mf6)<R, T, A1, A2, A3, A4, A5, A6, F>(f) {}
-};
-
-template<class R, class T, class A1, class A2, class A3, class A4, class A5, class A6> struct BOOST_MEM_FN_NAME(cmf6): public mf<R>::BOOST_NESTED_TEMPLATE BOOST_MEM_FN_NAME2(cmf6)<R, T, A1, A2, A3, A4, A5, A6, R (BOOST_MEM_FN_CC T::*) (A1, A2, A3, A4, A5, A6) const>
-{
-    typedef R (BOOST_MEM_FN_CC T::*F) (A1, A2, A3, A4, A5, A6) const;
-    explicit BOOST_MEM_FN_NAME(cmf6)(F f): mf<R>::BOOST_NESTED_TEMPLATE BOOST_MEM_FN_NAME2(cmf6)<R, T, A1, A2, A3, A4, A5, A6, F>(f) {}
-};
-
-
-template<class R, class T, class A1, class A2, class A3, class A4, class A5, class A6, class A7> struct BOOST_MEM_FN_NAME(mf7): public mf<R>::BOOST_NESTED_TEMPLATE BOOST_MEM_FN_NAME2(mf7)<R, T, A1, A2, A3, A4, A5, A6, A7, R (BOOST_MEM_FN_CC T::*) (A1, A2, A3, A4, A5, A6, A7)>
-{
-    typedef R (BOOST_MEM_FN_CC T::*F) (A1, A2, A3, A4, A5, A6, A7);
-    explicit BOOST_MEM_FN_NAME(mf7)(F f): mf<R>::BOOST_NESTED_TEMPLATE BOOST_MEM_FN_NAME2(mf7)<R, T, A1, A2, A3, A4, A5, A6, A7, F>(f) {}
-};
-
-template<class R, class T, class A1, class A2, class A3, class A4, class A5, class A6, class A7> struct BOOST_MEM_FN_NAME(cmf7): public mf<R>::BOOST_NESTED_TEMPLATE BOOST_MEM_FN_NAME2(cmf7)<R, T, A1, A2, A3, A4, A5, A6, A7, R (BOOST_MEM_FN_CC T::*) (A1, A2, A3, A4, A5, A6, A7) const>
-{
-    typedef R (BOOST_MEM_FN_CC T::*F) (A1, A2, A3, A4, A5, A6, A7) const;
-    explicit BOOST_MEM_FN_NAME(cmf7)(F f): mf<R>::BOOST_NESTED_TEMPLATE BOOST_MEM_FN_NAME2(cmf7)<R, T, A1, A2, A3, A4, A5, A6, A7, F>(f) {}
-};
-
-
-template<class R, class T, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8> struct BOOST_MEM_FN_NAME(mf8): public mf<R>::BOOST_NESTED_TEMPLATE BOOST_MEM_FN_NAME2(mf8)<R, T, A1, A2, A3, A4, A5, A6, A7, A8, R (BOOST_MEM_FN_CC T::*) (A1, A2, A3, A4, A5, A6, A7, A8)>
-{
-    typedef R (BOOST_MEM_FN_CC T::*F) (A1, A2, A3, A4, A5, A6, A7, A8);
-    explicit BOOST_MEM_FN_NAME(mf8)(F f): mf<R>::BOOST_NESTED_TEMPLATE BOOST_MEM_FN_NAME2(mf8)<R, T, A1, A2, A3, A4, A5, A6, A7, A8, F>(f) {}
-};
-
-template<class R, class T, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8> struct BOOST_MEM_FN_NAME(cmf8): public mf<R>::BOOST_NESTED_TEMPLATE BOOST_MEM_FN_NAME2(cmf8)<R, T, A1, A2, A3, A4, A5, A6, A7, A8, R (BOOST_MEM_FN_CC T::*) (A1, A2, A3, A4, A5, A6, A7, A8) const>
-{
-    typedef R (BOOST_MEM_FN_CC T::*F) (A1, A2, A3, A4, A5, A6, A7, A8) const;
-    explicit BOOST_MEM_FN_NAME(cmf8)(F f): mf<R>::BOOST_NESTED_TEMPLATE BOOST_MEM_FN_NAME2(cmf8)<R, T, A1, A2, A3, A4, A5, A6, A7, A8, F>(f) {}
-};
-
--- a/include/boost/bind/protect.hpp
+++ b/include/boost/bind/protect.hpp
@@ -12,6 +12,7 @@
 // http://www.boost.org/LICENSE_1_0.txt)
 //

+#include <boost/bind/detail/requires_cxx11.hpp>
 #include <boost/config.hpp>
 #include <boost/config/workaround.hpp>
 #include <utility>
@@ -22,7 +23,7 @@ namespace boost
 namespace _bi
 {

-#if !defined(BOOST_NO_CXX11_VARIADIC_TEMPLATES) && !defined(BOOST_NO_CXX11_RVALUE_REFERENCES) && !defined(BOOST_NO_CXX11_DECLTYPE)
+#if !defined(BOOST_NO_CXX11_VARIADIC_TEMPLATES) && !defined(BOOST_NO_CXX11_RVALUE_REFERENCES) && !defined(BOOST_NO_CXX11_DECLTYPE) && !(defined(BOOST_GCC) && BOOST_GCC < 40600)

 template<class T> struct protect_make_void
 {
--- a/include/boost/bind/std_placeholders.hpp
+++ b/include/boost/bind/std_placeholders.hpp
@@ -11,6 +11,7 @@
 // Distributed under the Boost Software License, Version 1.0.
 // https://www.boost.org/LICENSE_1_0.txt

+#include <boost/bind/detail/requires_cxx11.hpp>
 #include <boost/is_placeholder.hpp>
 #include <boost/config.hpp>

--- a/include/boost/bind/storage.hpp
+++ b/include/boost/bind/storage.hpp
@@ -21,6 +21,7 @@
 //  See http://www.boost.org/libs/bind/bind.html for documentation.
 //

+#include <boost/bind/detail/requires_cxx11.hpp>
 #include <boost/config.hpp>
 #include <boost/bind/arg.hpp>

--- a/test/Jamfile.v2
+++ b/test/Jamfile.v2
@@ -83,3 +83,6 @@ run apply_test.cpp ;
 run apply_test2.cpp ;
 run apply_rv_test.cpp ;
 run apply_rv_test2.cpp ;
+run bind_over_test.cpp ;
+run bind_over_mf_test.cpp ;
+run bind_over_mf2_test.cpp ;
--- a/test/apply_test2.cpp
+++ b/test/apply_test2.cpp
@@ -4,12 +4,11 @@

 #include <boost/bind/apply.hpp>
 #include <boost/core/lightweight_test_trait.hpp>
-#include <boost/core/is_same.hpp>

 int main()
 {
-    BOOST_TEST_TRAIT_TRUE((boost::core::is_same<void, boost::apply<void>::result_type>));
-    BOOST_TEST_TRAIT_TRUE((boost::core::is_same<int&, boost::apply<int&>::result_type>));
+    BOOST_TEST_TRAIT_SAME(void, boost::apply<void>::result_type);
+    BOOST_TEST_TRAIT_SAME(int&, boost::apply<int&>::result_type);

    return boost::report_errors();
 }
--- a/test/bind_function2_test.cpp
+++ b/test/bind_function2_test.cpp
@@ -1,4 +1,12 @@
 #include <boost/config.hpp>
+#include <boost/config/pragma_message.hpp>
+
+#if !defined(BOOST_NO_CXX11_RVALUE_REFERENCES) && ( defined(BOOST_GCC) && BOOST_GCC < 40600 )
+
+BOOST_PRAGMA_MESSAGE( "Skipping test for GCC 4.4 -std=c++0x" )
+int main() {}
+
+#else

 //
 //  bind_function2_test.cpp - regression test
@@ -118,3 +126,5 @@ int main()
    function_test();
    return boost::report_errors();
 }
+
+#endif
--- a/test/bind_function_ap_test.cpp
+++ b/test/bind_function_ap_test.cpp
@@ -1,4 +1,5 @@
 #include <boost/config.hpp>
+#include <boost/config/pragma_message.hpp>

 //
 //  bind_function_ap_test.cpp - regression test
@@ -10,11 +11,15 @@
 //  http://www.boost.org/LICENSE_1_0.txt
 //

-#if defined( BOOST_NO_AUTO_PTR )
+#if defined(BOOST_NO_AUTO_PTR)

-int main()
-{
-}
+BOOST_PRAGMA_MESSAGE( "Skipping test because BOOST_NO_AUTO_PTR is defined" )
+int main() {}
+
+#elif !defined(BOOST_NO_CXX11_RVALUE_REFERENCES) && ( defined(BOOST_GCC) && BOOST_GCC < 40600 )
+
+BOOST_PRAGMA_MESSAGE( "Skipping test for GCC 4.4 -std=c++0x" )
+int main() {}

 #else

@@ -233,4 +238,4 @@ int main()
    return boost::report_errors();
 }

-#endif // #if defined( BOOST_NO_AUTO_PTR )
+#endif
--- a/test/bind_over_mf2_test.cpp
+++ b/test/bind_over_mf2_test.cpp
@@ -0,0 +1,93 @@
+//
+// bind_over_mf2_test.cpp - overloaded member functions, type<> syntax
+//
+// Copyright 2017, 2024 Peter Dimov
+//
+// Distributed under the Boost Software License, Version 1.0.
+// See accompanying file LICENSE_1_0.txt or copy at
+// http://www.boost.org/LICENSE_1_0.txt)
+//
+
+#include <boost/bind/bind.hpp>
+#include <boost/type.hpp>
+#include <boost/core/lightweight_test.hpp>
+
+//
+
+struct X
+{
+    int f() { return 17041; }
+    int f( int x1 ) { return x1; }
+    int f( int x1, int x2 ) { return x1+x2; }
+    int f( int x1, int x2, int x3 ) { return x1+x2+x3; }
+    int f( int x1, int x2, int x3, int x4 ) { return x1+x2+x3+x4; }
+    int f( int x1, int x2, int x3, int x4, int x5 ) { return x1+x2+x3+x4+x5; }
+    int f( int x1, int x2, int x3, int x4, int x5, int x6 ) { return x1+x2+x3+x4+x5+x6; }
+    int f( int x1, int x2, int x3, int x4, int x5, int x6, int x7 ) { return x1+x2+x3+x4+x5+x6+x7; }
+    int f( int x1, int x2, int x3, int x4, int x5, int x6, int x7, int x8 ) { return x1+x2+x3+x4+x5+x6+x7+x8; }
+    int f( int x1, int x2, int x3, int x4, int x5, int x6, int x7, int x8, int x9 ) { return x1+x2+x3+x4+x5+x6+x7+x8+x9; }
+
+    int g() const { return 17041; }
+    int g( int x1 ) const { return x1; }
+    int g( int x1, int x2 ) const { return x1+x2; }
+    int g( int x1, int x2, int x3 ) const { return x1+x2+x3; }
+    int g( int x1, int x2, int x3, int x4 ) const { return x1+x2+x3+x4; }
+    int g( int x1, int x2, int x3, int x4, int x5 ) const { return x1+x2+x3+x4+x5; }
+    int g( int x1, int x2, int x3, int x4, int x5, int x6 ) const { return x1+x2+x3+x4+x5+x6; }
+    int g( int x1, int x2, int x3, int x4, int x5, int x6, int x7 ) const { return x1+x2+x3+x4+x5+x6+x7; }
+    int g( int x1, int x2, int x3, int x4, int x5, int x6, int x7, int x8 ) const { return x1+x2+x3+x4+x5+x6+x7+x8; }
+    int g( int x1, int x2, int x3, int x4, int x5, int x6, int x7, int x8, int x9 ) const { return x1+x2+x3+x4+x5+x6+x7+x8+x9; }
+};
+
+void overloaded_member_function_test()
+{
+    X x;
+
+    BOOST_TEST_EQ( boost::bind( boost::type<int>(), &X::f, &x )(), 17041 );
+    BOOST_TEST_EQ( boost::bind( boost::type<int>(), &X::f, &x, 1 )(), 1 );
+    BOOST_TEST_EQ( boost::bind( boost::type<int>(), &X::f, &x, 1, 2 )(), 1+2 );
+    BOOST_TEST_EQ( boost::bind( boost::type<int>(), &X::f, &x, 1, 2, 3 )(), 1+2+3 );
+    BOOST_TEST_EQ( boost::bind( boost::type<int>(), &X::f, &x, 1, 2, 3, 4 )(), 1+2+3+4 );
+    BOOST_TEST_EQ( boost::bind( boost::type<int>(), &X::f, &x, 1, 2, 3, 4, 5 )(), 1+2+3+4+5 );
+    BOOST_TEST_EQ( boost::bind( boost::type<int>(), &X::f, &x, 1, 2, 3, 4, 5, 6 )(), 1+2+3+4+5+6 );
+    BOOST_TEST_EQ( boost::bind( boost::type<int>(), &X::f, &x, 1, 2, 3, 4, 5, 6, 7 )(), 1+2+3+4+5+6+7 );
+    BOOST_TEST_EQ( boost::bind( boost::type<int>(), &X::f, &x, 1, 2, 3, 4, 5, 6, 7, 8 )(), 1+2+3+4+5+6+7+8 );
+
+    BOOST_TEST_EQ( boost::bind( boost::type<long>(), &X::f, &x )(), 17041 );
+    BOOST_TEST_EQ( boost::bind( boost::type<long>(), &X::f, &x, 1 )(), 1 );
+    BOOST_TEST_EQ( boost::bind( boost::type<long>(), &X::f, &x, 1, 2 )(), 1+2 );
+    BOOST_TEST_EQ( boost::bind( boost::type<long>(), &X::f, &x, 1, 2, 3 )(), 1+2+3 );
+    BOOST_TEST_EQ( boost::bind( boost::type<long>(), &X::f, &x, 1, 2, 3, 4 )(), 1+2+3+4 );
+    BOOST_TEST_EQ( boost::bind( boost::type<long>(), &X::f, &x, 1, 2, 3, 4, 5 )(), 1+2+3+4+5 );
+    BOOST_TEST_EQ( boost::bind( boost::type<long>(), &X::f, &x, 1, 2, 3, 4, 5, 6 )(), 1+2+3+4+5+6 );
+    BOOST_TEST_EQ( boost::bind( boost::type<long>(), &X::f, &x, 1, 2, 3, 4, 5, 6, 7 )(), 1+2+3+4+5+6+7 );
+    BOOST_TEST_EQ( boost::bind( boost::type<long>(), &X::f, &x, 1, 2, 3, 4, 5, 6, 7, 8 )(), 1+2+3+4+5+6+7+8 );
+
+    X const* pcx = &x;
+
+    BOOST_TEST_EQ( boost::bind( boost::type<int>(), &X::g, pcx )(), 17041 );
+    BOOST_TEST_EQ( boost::bind( boost::type<int>(), &X::g, pcx, 1 )(), 1 );
+    BOOST_TEST_EQ( boost::bind( boost::type<int>(), &X::g, pcx, 1, 2 )(), 1+2 );
+    BOOST_TEST_EQ( boost::bind( boost::type<int>(), &X::g, pcx, 1, 2, 3 )(), 1+2+3 );
+    BOOST_TEST_EQ( boost::bind( boost::type<int>(), &X::g, pcx, 1, 2, 3, 4 )(), 1+2+3+4 );
+    BOOST_TEST_EQ( boost::bind( boost::type<int>(), &X::g, pcx, 1, 2, 3, 4, 5 )(), 1+2+3+4+5 );
+    BOOST_TEST_EQ( boost::bind( boost::type<int>(), &X::g, pcx, 1, 2, 3, 4, 5, 6 )(), 1+2+3+4+5+6 );
+    BOOST_TEST_EQ( boost::bind( boost::type<int>(), &X::g, pcx, 1, 2, 3, 4, 5, 6, 7 )(), 1+2+3+4+5+6+7 );
+    BOOST_TEST_EQ( boost::bind( boost::type<int>(), &X::g, pcx, 1, 2, 3, 4, 5, 6, 7, 8 )(), 1+2+3+4+5+6+7+8 );
+
+    BOOST_TEST_EQ( boost::bind( boost::type<long>(), &X::g, pcx )(), 17041 );
+    BOOST_TEST_EQ( boost::bind( boost::type<long>(), &X::g, pcx, 1 )(), 1 );
+    BOOST_TEST_EQ( boost::bind( boost::type<long>(), &X::g, pcx, 1, 2 )(), 1+2 );
+    BOOST_TEST_EQ( boost::bind( boost::type<long>(), &X::g, pcx, 1, 2, 3 )(), 1+2+3 );
+    BOOST_TEST_EQ( boost::bind( boost::type<long>(), &X::g, pcx, 1, 2, 3, 4 )(), 1+2+3+4 );
+    BOOST_TEST_EQ( boost::bind( boost::type<long>(), &X::g, pcx, 1, 2, 3, 4, 5 )(), 1+2+3+4+5 );
+    BOOST_TEST_EQ( boost::bind( boost::type<long>(), &X::g, pcx, 1, 2, 3, 4, 5, 6 )(), 1+2+3+4+5+6 );
+    BOOST_TEST_EQ( boost::bind( boost::type<long>(), &X::g, pcx, 1, 2, 3, 4, 5, 6, 7 )(), 1+2+3+4+5+6+7 );
+    BOOST_TEST_EQ( boost::bind( boost::type<long>(), &X::g, pcx, 1, 2, 3, 4, 5, 6, 7, 8 )(), 1+2+3+4+5+6+7+8 );
+}
+
+int main()
+{
+    overloaded_member_function_test();
+    return boost::report_errors();
+}
--- a/test/bind_over_mf_test.cpp
+++ b/test/bind_over_mf_test.cpp
@@ -0,0 +1,112 @@
+//
+// bind_over_mf_test.cpp - overloaded member functions
+//
+// Copyright 2017, 2024 Peter Dimov
+//
+// Distributed under the Boost Software License, Version 1.0.
+// See accompanying file LICENSE_1_0.txt or copy at
+// http://www.boost.org/LICENSE_1_0.txt)
+//
+
+#include <boost/bind/bind.hpp>
+#include <boost/core/lightweight_test.hpp>
+
+//
+
+struct X
+{
+    int f() { return 17041; }
+    int f( int x1 ) { return x1; }
+    int f( int x1, int x2 ) { return x1+x2; }
+    int f( int x1, int x2, int x3 ) { return x1+x2+x3; }
+    int f( int x1, int x2, int x3, int x4 ) { return x1+x2+x3+x4; }
+    int f( int x1, int x2, int x3, int x4, int x5 ) { return x1+x2+x3+x4+x5; }
+    int f( int x1, int x2, int x3, int x4, int x5, int x6 ) { return x1+x2+x3+x4+x5+x6; }
+    int f( int x1, int x2, int x3, int x4, int x5, int x6, int x7 ) { return x1+x2+x3+x4+x5+x6+x7; }
+    int f( int x1, int x2, int x3, int x4, int x5, int x6, int x7, int x8 ) { return x1+x2+x3+x4+x5+x6+x7+x8; }
+    int f( int x1, int x2, int x3, int x4, int x5, int x6, int x7, int x8, int x9 ) { return x1+x2+x3+x4+x5+x6+x7+x8+x9; }
+
+    int g() const { return 17041; }
+    int g( int x1 ) const { return x1; }
+    int g( int x1, int x2 ) const { return x1+x2; }
+    int g( int x1, int x2, int x3 ) const { return x1+x2+x3; }
+    int g( int x1, int x2, int x3, int x4 ) const { return x1+x2+x3+x4; }
+    int g( int x1, int x2, int x3, int x4, int x5 ) const { return x1+x2+x3+x4+x5; }
+    int g( int x1, int x2, int x3, int x4, int x5, int x6 ) const { return x1+x2+x3+x4+x5+x6; }
+    int g( int x1, int x2, int x3, int x4, int x5, int x6, int x7 ) const { return x1+x2+x3+x4+x5+x6+x7; }
+    int g( int x1, int x2, int x3, int x4, int x5, int x6, int x7, int x8 ) const { return x1+x2+x3+x4+x5+x6+x7+x8; }
+    int g( int x1, int x2, int x3, int x4, int x5, int x6, int x7, int x8, int x9 ) const { return x1+x2+x3+x4+x5+x6+x7+x8+x9; }
+};
+
+void overloaded_member_function_test()
+{
+    X x;
+
+    BOOST_TEST_EQ( boost::bind( &X::f, &x )(), 17041 );
+    BOOST_TEST_EQ( boost::bind( &X::f, &x, 1 )(), 1 );
+    BOOST_TEST_EQ( boost::bind( &X::f, &x, 1, 2 )(), 1+2 );
+    BOOST_TEST_EQ( boost::bind( &X::f, &x, 1, 2, 3 )(), 1+2+3 );
+    BOOST_TEST_EQ( boost::bind( &X::f, &x, 1, 2, 3, 4 )(), 1+2+3+4 );
+    BOOST_TEST_EQ( boost::bind( &X::f, &x, 1, 2, 3, 4, 5 )(), 1+2+3+4+5 );
+    BOOST_TEST_EQ( boost::bind( &X::f, &x, 1, 2, 3, 4, 5, 6 )(), 1+2+3+4+5+6 );
+    BOOST_TEST_EQ( boost::bind( &X::f, &x, 1, 2, 3, 4, 5, 6, 7 )(), 1+2+3+4+5+6+7 );
+    BOOST_TEST_EQ( boost::bind( &X::f, &x, 1, 2, 3, 4, 5, 6, 7, 8 )(), 1+2+3+4+5+6+7+8 );
+
+    BOOST_TEST_EQ( boost::bind<int>( &X::f, &x )(), 17041 );
+    BOOST_TEST_EQ( boost::bind<int>( &X::f, &x, 1 )(), 1 );
+    BOOST_TEST_EQ( boost::bind<int>( &X::f, &x, 1, 2 )(), 1+2 );
+    BOOST_TEST_EQ( boost::bind<int>( &X::f, &x, 1, 2, 3 )(), 1+2+3 );
+    BOOST_TEST_EQ( boost::bind<int>( &X::f, &x, 1, 2, 3, 4 )(), 1+2+3+4 );
+    BOOST_TEST_EQ( boost::bind<int>( &X::f, &x, 1, 2, 3, 4, 5 )(), 1+2+3+4+5 );
+    BOOST_TEST_EQ( boost::bind<int>( &X::f, &x, 1, 2, 3, 4, 5, 6 )(), 1+2+3+4+5+6 );
+    BOOST_TEST_EQ( boost::bind<int>( &X::f, &x, 1, 2, 3, 4, 5, 6, 7 )(), 1+2+3+4+5+6+7 );
+    BOOST_TEST_EQ( boost::bind<int>( &X::f, &x, 1, 2, 3, 4, 5, 6, 7, 8 )(), 1+2+3+4+5+6+7+8 );
+
+    BOOST_TEST_EQ( boost::bind<long>( &X::f, &x )(), 17041 );
+    BOOST_TEST_EQ( boost::bind<long>( &X::f, &x, 1 )(), 1 );
+    BOOST_TEST_EQ( boost::bind<long>( &X::f, &x, 1, 2 )(), 1+2 );
+    BOOST_TEST_EQ( boost::bind<long>( &X::f, &x, 1, 2, 3 )(), 1+2+3 );
+    BOOST_TEST_EQ( boost::bind<long>( &X::f, &x, 1, 2, 3, 4 )(), 1+2+3+4 );
+    BOOST_TEST_EQ( boost::bind<long>( &X::f, &x, 1, 2, 3, 4, 5 )(), 1+2+3+4+5 );
+    BOOST_TEST_EQ( boost::bind<long>( &X::f, &x, 1, 2, 3, 4, 5, 6 )(), 1+2+3+4+5+6 );
+    BOOST_TEST_EQ( boost::bind<long>( &X::f, &x, 1, 2, 3, 4, 5, 6, 7 )(), 1+2+3+4+5+6+7 );
+    BOOST_TEST_EQ( boost::bind<long>( &X::f, &x, 1, 2, 3, 4, 5, 6, 7, 8 )(), 1+2+3+4+5+6+7+8 );
+
+    X const* pcx = &x;
+
+    BOOST_TEST_EQ( boost::bind( &X::g, pcx )(), 17041 );
+    BOOST_TEST_EQ( boost::bind( &X::g, pcx, 1 )(), 1 );
+    BOOST_TEST_EQ( boost::bind( &X::g, pcx, 1, 2 )(), 1+2 );
+    BOOST_TEST_EQ( boost::bind( &X::g, pcx, 1, 2, 3 )(), 1+2+3 );
+    BOOST_TEST_EQ( boost::bind( &X::g, pcx, 1, 2, 3, 4 )(), 1+2+3+4 );
+    BOOST_TEST_EQ( boost::bind( &X::g, pcx, 1, 2, 3, 4, 5 )(), 1+2+3+4+5 );
+    BOOST_TEST_EQ( boost::bind( &X::g, pcx, 1, 2, 3, 4, 5, 6 )(), 1+2+3+4+5+6 );
+    BOOST_TEST_EQ( boost::bind( &X::g, pcx, 1, 2, 3, 4, 5, 6, 7 )(), 1+2+3+4+5+6+7 );
+    BOOST_TEST_EQ( boost::bind( &X::g, pcx, 1, 2, 3, 4, 5, 6, 7, 8 )(), 1+2+3+4+5+6+7+8 );
+
+    BOOST_TEST_EQ( boost::bind<int>( &X::g, pcx )(), 17041 );
+    BOOST_TEST_EQ( boost::bind<int>( &X::g, pcx, 1 )(), 1 );
+    BOOST_TEST_EQ( boost::bind<int>( &X::g, pcx, 1, 2 )(), 1+2 );
+    BOOST_TEST_EQ( boost::bind<int>( &X::g, pcx, 1, 2, 3 )(), 1+2+3 );
+    BOOST_TEST_EQ( boost::bind<int>( &X::g, pcx, 1, 2, 3, 4 )(), 1+2+3+4 );
+    BOOST_TEST_EQ( boost::bind<int>( &X::g, pcx, 1, 2, 3, 4, 5 )(), 1+2+3+4+5 );
+    BOOST_TEST_EQ( boost::bind<int>( &X::g, pcx, 1, 2, 3, 4, 5, 6 )(), 1+2+3+4+5+6 );
+    BOOST_TEST_EQ( boost::bind<int>( &X::g, pcx, 1, 2, 3, 4, 5, 6, 7 )(), 1+2+3+4+5+6+7 );
+    BOOST_TEST_EQ( boost::bind<int>( &X::g, pcx, 1, 2, 3, 4, 5, 6, 7, 8 )(), 1+2+3+4+5+6+7+8 );
+
+    BOOST_TEST_EQ( boost::bind<long>( &X::g, pcx )(), 17041 );
+    BOOST_TEST_EQ( boost::bind<long>( &X::g, pcx, 1 )(), 1 );
+    BOOST_TEST_EQ( boost::bind<long>( &X::g, pcx, 1, 2 )(), 1+2 );
+    BOOST_TEST_EQ( boost::bind<long>( &X::g, pcx, 1, 2, 3 )(), 1+2+3 );
+    BOOST_TEST_EQ( boost::bind<long>( &X::g, pcx, 1, 2, 3, 4 )(), 1+2+3+4 );
+    BOOST_TEST_EQ( boost::bind<long>( &X::g, pcx, 1, 2, 3, 4, 5 )(), 1+2+3+4+5 );
+    BOOST_TEST_EQ( boost::bind<long>( &X::g, pcx, 1, 2, 3, 4, 5, 6 )(), 1+2+3+4+5+6 );
+    BOOST_TEST_EQ( boost::bind<long>( &X::g, pcx, 1, 2, 3, 4, 5, 6, 7 )(), 1+2+3+4+5+6+7 );
+    BOOST_TEST_EQ( boost::bind<long>( &X::g, pcx, 1, 2, 3, 4, 5, 6, 7, 8 )(), 1+2+3+4+5+6+7+8 );
+}
+
+int main()
+{
+    overloaded_member_function_test();
+    return boost::report_errors();
+}
--- a/test/bind_over_test.cpp
+++ b/test/bind_over_test.cpp
@@ -0,0 +1,86 @@
+//
+// bind_over_test.cpp - overloaded functions
+//
+// Copyright 2017, 2024 Peter Dimov
+//
+// Distributed under the Boost Software License, Version 1.0.
+// See accompanying file LICENSE_1_0.txt or copy at
+// http://www.boost.org/LICENSE_1_0.txt)
+//
+
+#include <boost/bind/bind.hpp>
+#include <boost/core/lightweight_test.hpp>
+
+using namespace boost::placeholders;
+
+//
+
+int f()
+{
+    return 17041;
+}
+
+int f( int x1 )
+{
+    return x1;
+}
+
+int f( int x1, int x2 )
+{
+    return x1+x2;
+}
+
+int f( int x1, int x2, int x3 )
+{
+    return x1+x2+x3;
+}
+
+int f( int x1, int x2, int x3, int x4 )
+{
+    return x1+x2+x3+x4;
+}
+
+int f( int x1, int x2, int x3, int x4, int x5 )
+{
+    return x1+x2+x3+x4+x5;
+}
+
+int f( int x1, int x2, int x3, int x4, int x5, int x6 )
+{
+    return x1+x2+x3+x4+x5+x6;
+}
+
+int f( int x1, int x2, int x3, int x4, int x5, int x6, int x7 )
+{
+    return x1+x2+x3+x4+x5+x6+x7;
+}
+
+int f( int x1, int x2, int x3, int x4, int x5, int x6, int x7, int x8 )
+{
+    return x1+x2+x3+x4+x5+x6+x7+x8;
+}
+
+int f( int x1, int x2, int x3, int x4, int x5, int x6, int x7, int x8, int x9 )
+{
+    return x1+x2+x3+x4+x5+x6+x7+x8+x9;
+}
+
+void overloaded_function_test()
+{
+    BOOST_TEST_EQ( boost::bind( f )(), 17041 );
+    BOOST_TEST_EQ( boost::bind( f, 1 )(), 1 );
+    BOOST_TEST_EQ( boost::bind( f, 1, 2 )(), 1+2 );
+    BOOST_TEST_EQ( boost::bind( f, 1, 2, 3 )(), 1+2+3 );
+    BOOST_TEST_EQ( boost::bind( f, 1, 2, 3, 4 )(), 1+2+3+4 );
+    BOOST_TEST_EQ( boost::bind( f, 1, 2, 3, 4, 5 )(), 1+2+3+4+5 );
+    BOOST_TEST_EQ( boost::bind( f, 1, 2, 3, 4, 5, 6 )(), 1+2+3+4+5+6 );
+    BOOST_TEST_EQ( boost::bind( f, 1, 2, 3, 4, 5, 6, 7 )(), 1+2+3+4+5+6+7 );
+    BOOST_TEST_EQ( boost::bind( f, 1, 2, 3, 4, 5, 6, 7, 8 )(), 1+2+3+4+5+6+7+8 );
+    BOOST_TEST_EQ( boost::bind( f, 1, 2, 3, 4, 5, 6, 7, 8, 9 )(), 1+2+3+4+5+6+7+8+9 );
+}
+
+int main()
+{
+    overloaded_function_test();
+    return boost::report_errors();
+}
--- a/test/bind_unique_ptr_test.cpp
+++ b/test/bind_unique_ptr_test.cpp
@@ -1,10 +1,20 @@
 #include <boost/config.hpp>
+#include <boost/config/pragma_message.hpp>

-#if defined( BOOST_NO_CXX11_RVALUE_REFERENCES ) || defined( BOOST_NO_CXX11_SMART_PTR )
+#if defined(BOOST_NO_CXX11_RVALUE_REFERENCES)

-int main()
-{
-}
+BOOST_PRAGMA_MESSAGE( "Skipping test because BOOST_NO_CXX11_RVALUE_REFERENCES is defined" )
+int main() {}
+
+#elif defined(BOOST_NO_CXX11_SMART_PTR)
+
+BOOST_PRAGMA_MESSAGE( "Skipping test because BOOST_NO_CXX11_SMART_PTR is defined" )
+int main() {}
+
+#elif defined(BOOST_GCC) && BOOST_GCC < 40600
+
+BOOST_PRAGMA_MESSAGE( "Skipping test because BOOST_GCC is less than 40600" )
+int main() {}

 #else

@@ -206,4 +216,4 @@ int main()
    return boost::report_errors();
 }

-#endif // #if defined( BOOST_NO_CXX11_RVALUE_REFERENCES ) || defined( BOOST_NO_CXX11_SMART_PTR )
+#endif
--- a/test/cmake_subdir_test/CMakeLists.txt
+++ b/test/cmake_subdir_test/CMakeLists.txt
@@ -10,6 +10,8 @@ add_subdirectory(../.. boostorg/bind)
 add_subdirectory(../../../assert boostorg/assert)
 add_subdirectory(../../../config boostorg/config)
 add_subdirectory(../../../core boostorg/core)
+add_subdirectory(../../../static_assert boostorg/static_assert)
+add_subdirectory(../../../throw_exception boostorg/throw_exception)

 add_executable(quick ../quick.cpp)
 target_link_libraries(quick Boost::bind Boost::core)
--- a/test/placeholder_std_bind_test.cpp
+++ b/test/placeholder_std_bind_test.cpp
@@ -9,12 +9,17 @@
 //

 #include <boost/config.hpp>
+#include <boost/config/pragma_message.hpp>

-#if defined( BOOST_NO_CXX11_HDR_FUNCTIONAL )
+#if defined(BOOST_NO_CXX11_HDR_FUNCTIONAL)

-int main()
-{
-}
+BOOST_PRAGMA_MESSAGE( "Skipping test because BOOST_NO_CXX11_HDR_FUNCTIONAL is defined" )
+int main() {}
+
+#elif defined(BOOST_GCC) && BOOST_GCC < 40600
+
+BOOST_PRAGMA_MESSAGE( "Skipping test because BOOST_GCC is less than 40600" )
+int main() {}

 #else

--- a/test/protect_test2.cpp
+++ b/test/protect_test2.cpp
@@ -6,11 +6,10 @@

 #include <boost/bind/protect.hpp>
 #include <boost/core/lightweight_test_trait.hpp>
-#include <boost/core/is_same.hpp>

 template<class T, class F> void test( F )
 {
-    BOOST_TEST_TRAIT_TRUE((boost::core::is_same<typename T::result_type, typename F::result_type>));
+    BOOST_TEST_TRAIT_SAME(typename T::result_type, typename F::result_type);
 }

 struct X
@@ -29,14 +28,14 @@ template<class T, class U> struct inherit: T, U
 template<class F> void test2( F )
 {
    // test that F doesn't have ::result_type
-    BOOST_TEST_TRAIT_TRUE((boost::core::is_same<typename inherit<F, X>::result_type, typename X::result_type>));
+    BOOST_TEST_TRAIT_SAME(typename inherit<F, X>::result_type, typename X::result_type);
 }

 int main()
 {
    test<X>( boost::protect( X() ) );

-#if !defined(BOOST_NO_CXX11_VARIADIC_TEMPLATES) && !defined(BOOST_NO_CXX11_RVALUE_REFERENCES) && !defined(BOOST_NO_CXX11_DECLTYPE)
+#if !defined(BOOST_NO_CXX11_VARIADIC_TEMPLATES) && !defined(BOOST_NO_CXX11_RVALUE_REFERENCES) && !defined(BOOST_NO_CXX11_DECLTYPE) && !(defined(BOOST_GCC) && BOOST_GCC < 40600)

    test2( boost::protect( Y() ) );
Author	SHA1	Message	Date
Peter Dimov	74308ee223	Add bind_over_mf2_test.cpp	2024-01-04 20:56:32 +02:00
Peter Dimov	6926dbfc51	Expand bind_over_mf_test.cpp	2024-01-04 20:49:06 +02:00
Peter Dimov	1d123d6432	Add bind_over_mf_test.cpp	2024-01-04 20:36:39 +02:00
Peter Dimov	9b9851a887	Add bind_over_test.cpp	2024-01-04 20:26:54 +02:00
Peter Dimov	732bc0787c	Remove BOOST_NO_VOID_RETURNS code path from bind.hpp	2024-01-02 20:09:20 +02:00
Peter Dimov	645d30d455	Remove unnecessary macros from mem_fn.hpp	2024-01-02 19:55:36 +02:00
Peter Dimov	08e5b5831c	Remove BOOST_NO_VOID_RETURNS code path from mem_fn.hpp	2024-01-02 19:47:55 +02:00
Peter Dimov	d9b74619b7	Update ci.yml	2024-01-02 19:04:31 +02:00
Peter Dimov	6892ffa0a3	Update .drone.jsonnet	2024-01-02 18:41:32 +02:00
Peter Dimov	586d4e1fb0	Update ci.yml	2023-10-18 14:03:41 +03:00
Peter Dimov	186b9c66de	Update C++03 deprecation message	2023-10-18 14:00:38 +03:00
Peter Dimov	55d037093b	Update C++03 deprecation message	2023-06-03 02:25:23 +03:00
Peter Dimov	8d945a9733	Update .drone.jsonnet	2023-03-04 20:12:04 +02:00
Peter Dimov	a421c908e3	Add notice for C++03 deprecation	2023-03-04 19:58:19 +02:00
Peter Dimov	41dda10827	Update ci.yml	2023-03-04 17:53:35 +02:00
Peter Dimov	9a59a15e28	Use BOOST_TEST_TRAIT_SAME	2022-12-23 05:38:26 +02:00
Peter Dimov	395235f3aa	Update ci.yml	2022-12-23 05:35:07 +02:00
Peter Dimov	f1e32ceb6d	Merge pull request #31 from Lastique/feature/update_is_same Use `is_same` from Boost.TypeTraits	2022-12-23 05:32:32 +02:00
Andrey Semashev	9493eaccad	Use a local copy of is_same trait. boost::core::is_same is deprecated, so use a local copy to avoid adding a dependency on Boost.TypeTraits. Use Boost.TypeTraits in tests. Also added a missing include.	2022-12-23 02:25:19 +03:00
Peter Dimov	cbd61ba5b9	Change macos-10.15 to macos-11 in ci.yml	2022-08-24 20:43:19 +03:00
Peter Dimov	fe0ade9c8f	Update cmake_subdir_test	2022-08-24 20:42:36 +03:00
Peter Dimov	b9e32ab23e	Add CMake tests to ci.yml	2022-08-24 20:04:22 +03:00
Peter Dimov	0abab115dd	Update ci.yml	2022-08-24 20:01:55 +03:00
Peter Dimov	20908f71e7	Merge pull request #29 from fanquake/point_to_bind_mem_fn refactor: use boost/bind/mem_fn over boost/mem_fn	2022-08-24 19:58:43 +03:00
fanquake	3a1b8da4b0	refactor: use boost/bind/mem_fn over boost/mem_fn The later just includes the former.	2022-08-23 16:12:04 +01:00
Peter Dimov	edc56d8442	Update .yml files	2022-02-12 22:40:47 +02:00
Peter Dimov	57d26f5ab3	libstdc++ 4.8 and below don't have std::bit_not. Fixes #28 .	2022-02-12 20:48:46 +02:00
Peter Dimov	f50916d0e1	Update tests	2022-02-12 19:13:09 +02:00
Peter Dimov	a5491d988a	Disable rvalue references on GCC 4.4	2022-02-12 18:53:29 +02:00
Peter Dimov	536721c41d	Disable placeholder_std_bind_test on GCC 4.4	2022-02-12 18:47:23 +02:00
Peter Dimov	f75413b14a	Add a workaround for GCC 4.4 to protect.hpp	2022-02-12 18:34:37 +02:00
Peter Dimov	988a8707b4	Update drone.sh permissions	2022-02-12 18:19:46 +02:00
Peter Dimov	f6026ae53f	Fix library name	2022-02-12 18:18:40 +02:00
Peter Dimov	5599f2210f	Add Drone files	2022-02-12 18:17:09 +02:00
Peter Dimov	24bd5e7e5b	Merge branch 'develop' into feature/result-traits	2021-10-01 01:56:25 +03:00
Peter Dimov	b0b2ed2814	Update ci.yml	2021-10-01 01:14:41 +03:00
Peter Dimov	b719777942	Do not rely on result_type for standard function objects on C++17 or above	2021-10-01 01:07:32 +03:00
Peter Dimov	5b1fe62dbb	Update ci.yml	2021-10-01 00:20:25 +03:00