Create branches/filesystem-v3 for v2 removal

[SVN r77385]
2012-03-18 20:54:17 +00:00
55 changed files with 517 additions and 3145 deletions
--- a/.drone.jsonnet
+++ b/.drone.jsonnet
@ -1,382 +0,0 @@
 # Copyright 2022 Peter Dimov
 # Distributed under the Boost Software License, Version 1.0.
 # https://www.boost.org/LICENSE_1_0.txt
 local library = "function";
 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 14.04 GCC 4.4",
        "cppalliance/droneubuntu1404:1",
        { TOOLSET: 'gcc', COMPILER: 'g++-4.4', CXXSTD: '98,0x' },
        "g++-4.4",
        [ "ppa:ubuntu-toolchain-r/test" ],
    ),
    linux_pipeline(
        "Linux 14.04 GCC 4.6 32/64",
        "cppalliance/droneubuntu1404:1",
        { TOOLSET: 'gcc', COMPILER: 'g++-4.6', CXXSTD: '98,0x', ADDRMD: '32,64' },
        "g++-4.6-multilib",
        [ "ppa:ubuntu-toolchain-r/test" ],
    ),
    linux_pipeline(
        "Linux 14.04 GCC 4.7 32/64",
        "cppalliance/droneubuntu1404:1",
        { TOOLSET: 'gcc', COMPILER: 'g++-4.7', CXXSTD: '98,0x', ADDRMD: '32,64' },
        "g++-4.7-multilib",
        [ "ppa:ubuntu-toolchain-r/test" ],
    ),
    linux_pipeline(
        "Linux 14.04 GCC 4.8* 32/64",
        "cppalliance/droneubuntu1404:1",
        { TOOLSET: 'gcc', COMPILER: 'g++', CXXSTD: '03,11', ADDRMD: '32,64' },
    ),
    linux_pipeline(
        "Linux 14.04 GCC 4.9 32/64",
        "cppalliance/droneubuntu1404:1",
        { TOOLSET: 'gcc', COMPILER: 'g++-4.9', CXXSTD: '03,11', ADDRMD: '32,64' },
        "g++-4.9-multilib",
        [ "ppa:ubuntu-toolchain-r/test" ],
    ),
    linux_pipeline(
        "Linux 16.04 GCC 5* 32/64",
        "cppalliance/droneubuntu1604:1",
        { TOOLSET: 'gcc', COMPILER: 'g++', CXXSTD: '03,11,14', ADDRMD: '32,64' },
    ),
    linux_pipeline(
        "Linux 18.04 GCC 6 32/64",
        "cppalliance/droneubuntu1804:1",
        { TOOLSET: 'gcc', COMPILER: 'g++-6', CXXSTD: '03,11,14', ADDRMD: '32,64' },
        "g++-6-multilib",
    ),
    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 32/64",
        "cppalliance/droneubuntu1804:1",
        { TOOLSET: 'gcc', COMPILER: 'g++-8', CXXSTD: '03,11,14,17', ADDRMD: '32,64' },
        "g++-8-multilib",
    ),
    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 16.04 Clang 3.5",
        "cppalliance/droneubuntu1604:1",
        { TOOLSET: 'clang', COMPILER: 'clang++-3.5', CXXSTD: '03,11' },
        "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 18.04 Clang 3.9",
        "cppalliance/droneubuntu1804:1",
        { TOOLSET: 'clang', COMPILER: 'clang++-3.9', CXXSTD: '03,11,14' },
        "clang-3.9",
    ),
    linux_pipeline(
        "Linux 18.04 Clang 4.0",
        "cppalliance/droneubuntu1804:1",
        { TOOLSET: 'clang', COMPILER: 'clang++-4.0', CXXSTD: '03,11,14' },
        "clang-4.0",
    ),
    linux_pipeline(
        "Linux 18.04 Clang 5.0",
        "cppalliance/droneubuntu1804:1",
        { TOOLSET: 'clang', COMPILER: 'clang++-5.0', CXXSTD: '03,11,14,1z' },
        "clang-5.0",
    ),
    linux_pipeline(
        "Linux 18.04 Clang 6.0",
        "cppalliance/droneubuntu1804:1",
        { TOOLSET: 'clang', COMPILER: 'clang++-6.0', CXXSTD: '03,11,14,17' },
        "clang-6.0",
    ),
    linux_pipeline(
        "Linux 20.04 Clang 7",
        "cppalliance/droneubuntu2004:1",
        { TOOLSET: 'clang', COMPILER: 'clang++-7', CXXSTD: '03,11,14,17' },
        "clang-7",
    ),
    linux_pipeline(
        "Linux 20.04 Clang 8",
        "cppalliance/droneubuntu2004:1",
        { TOOLSET: 'clang', COMPILER: 'clang++-8', CXXSTD: '03,11,14,17' },
        "clang-8",
    ),
    linux_pipeline(
        "Linux 20.04 Clang 9",
        "cppalliance/droneubuntu2004:1",
        { TOOLSET: 'clang', COMPILER: 'clang++-9', CXXSTD: '03,11,14,17,2a' },
        "clang-9",
    ),
    linux_pipeline(
        "Linux 20.04 Clang 10",
        "cppalliance/droneubuntu2004:1",
        { TOOLSET: 'clang', COMPILER: 'clang++-10', CXXSTD: '03,11,14,17,2a' },
        "clang-10",
    ),
    linux_pipeline(
        "Linux 20.04 Clang 11",
        "cppalliance/droneubuntu2004:1",
        { TOOLSET: 'clang', COMPILER: 'clang++-11', CXXSTD: '03,11,14,17,2a' },
        "clang-11",
    ),
    linux_pipeline(
        "Linux 20.04 Clang 12",
        "cppalliance/droneubuntu2004:1",
        { TOOLSET: 'clang', COMPILER: 'clang++-12', CXXSTD: '03,11,14,17,2a' },
        "clang-12",
    ),
    linux_pipeline(
        "Linux 22.04 Clang 13",
        "cppalliance/droneubuntu2204:1",
        { TOOLSET: 'clang', COMPILER: 'clang++-13', CXXSTD: '03,11,14,17,20' },
        "clang-13",
    ),
    linux_pipeline(
        "Linux 22.04 Clang 14 UBSAN",
        "cppalliance/droneubuntu2204:1",
        { TOOLSET: 'clang', COMPILER: 'clang++-14', CXXSTD: '03,11,14,17,20,2b' } + ubsan,
        "clang-14",
    ),
    linux_pipeline(
        "Linux 22.04 Clang 14 ASAN",
        "cppalliance/droneubuntu2204:1",
        { TOOLSET: 'clang', COMPILER: 'clang++-14', CXXSTD: '03,11,14,17,20,2b' } + asan,
        "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",
        ["deb http://apt.llvm.org/jammy/ llvm-toolchain-jammy-15 main"],
    ),
    macos_pipeline(
        "MacOS 10.15 Xcode 12.2 UBSAN",
        { TOOLSET: 'clang', COMPILER: 'clang++', CXXSTD: '03,11,14,17,2a' } + ubsan,
    ),
    macos_pipeline(
        "MacOS 10.15 Xcode 12.2 ASAN",
        { TOOLSET: 'clang', COMPILER: 'clang++', CXXSTD: '03,11,14,17,2a' } + 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' },
    ),
    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
@ -1,23 +0,0 @@
@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 -I example %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
@ -1,25 +0,0 @@
 #!/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 -I example $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
@ -1,609 +0,0 @@
 name: CI
 on:
  pull_request:
  push:
    branches:
      - master
      - develop
      - feature/**
 env:
  UBSAN_OPTIONS: print_stacktrace=1
 jobs:
  posix:
    strategy:
      fail-fast: false
      matrix:
        include:
          - toolset: gcc-4.8
            cxxstd: "03,11"
            os: ubuntu-latest
            container: ubuntu:18.04
            install: g++-4.8-multilib
            address-model: 32,64
          - toolset: gcc-5
            cxxstd: "03,11,14,1z"
            os: ubuntu-latest
            container: ubuntu:18.04
            install: g++-5-multilib
            address-model: 32,64
          - toolset: gcc-6
            cxxstd: "03,11,14,1z"
            os: ubuntu-latest
            container: ubuntu:18.04
            install: g++-6-multilib
            address-model: 32,64
          - toolset: gcc-7
            cxxstd: "03,11,14,17"
            os: ubuntu-20.04
            install: g++-7-multilib
            address-model: 32,64
          - toolset: gcc-8
            cxxstd: "03,11,14,17,2a"
            os: ubuntu-20.04
            install: g++-8-multilib
            address-model: 32,64
          - toolset: gcc-9
            cxxstd: "03,11,14,17,2a"
            os: ubuntu-20.04
            install: g++-9-multilib
            address-model: 32,64
          - toolset: gcc-10
            cxxstd: "03,11,14,17,2a"
            os: ubuntu-20.04
            install: g++-10-multilib
            address-model: 32,64
          - toolset: gcc-11
            cxxstd: "03,11,14,17,20,2b"
            os: ubuntu-22.04
            install: g++-11-multilib
            address-model: 32,64
          - toolset: gcc-12
            cxxstd: "03,11,14,17,20,2b"
            os: ubuntu-22.04
            install: g++-12-multilib
            address-model: 32,64
          - toolset: gcc-13
            cxxstd: "03,11,14,17,20,2b"
            os: ubuntu-latest
            container: ubuntu:23.04
            install: g++-13-multilib
            address-model: 32,64
          - toolset: clang
            compiler: clang++-3.9
            cxxstd: "03,11,14"
            os: ubuntu-latest
            container: ubuntu:18.04
            install: clang-3.9
          - toolset: clang
            compiler: clang++-4.0
            cxxstd: "03,11,14"
            os: ubuntu-latest
            container: ubuntu:18.04
            install: clang-4.0
          - toolset: clang
            compiler: clang++-5.0
            cxxstd: "03,11,14,1z"
            os: ubuntu-latest
            container: ubuntu:18.04
            install: clang-5.0
          - toolset: clang
            compiler: clang++-6.0
            cxxstd: "03,11,14,17"
            os: ubuntu-20.04
            install: clang-6.0
          - toolset: clang
            compiler: clang++-7
            cxxstd: "03,11,14,17"
            os: ubuntu-20.04
            install: clang-7
          - toolset: clang
            compiler: clang++-8
            cxxstd: "03,11,14,17"
            os: ubuntu-20.04
            install: clang-8
          - toolset: clang
            compiler: clang++-9
            cxxstd: "03,11,14,17"
            os: ubuntu-20.04
            install: clang-9
          - toolset: clang
            compiler: clang++-10
            cxxstd: "03,11,14,17,2a"
            os: ubuntu-20.04
          - toolset: clang
            compiler: clang++-11
            cxxstd: "03,11,14,17,2a"
            os: ubuntu-20.04
          - toolset: clang
            compiler: clang++-12
            cxxstd: "03,11,14,17,20"
            os: ubuntu-20.04
          - toolset: clang
            compiler: clang++-13
            cxxstd: "03,11,14,17,20"
            os: ubuntu-22.04
            install: clang-13
          - toolset: clang
            compiler: clang++-14
            cxxstd: "03,11,14,17,20,2b"
            os: ubuntu-22.04
            install: clang-14
          - toolset: clang
            compiler: clang++-15
            cxxstd: "03,11,14,17,20,2b"
            os: ubuntu-22.04
            install: clang-15
          - toolset: clang
            compiler: clang++-16
            cxxstd: "03,11,14,17,20,2b"
            os: ubuntu-latest
            container: ubuntu:23.04
            install: clang-16
          - toolset: clang
            cxxstd: "03,11,14,17,2a"
            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@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-get update
          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
          python3 tools/boostdep/depinst/depinst.py --git_args "--jobs 3" $LIBRARY
          ./bootstrap.sh
          ./b2 -d0 headers
      - name: Create user-config.jam
        if: matrix.compiler
        run: |
          echo "using ${{matrix.toolset}} : : ${{matrix.compiler}} ;" > ~/user-config.jam
      - name: Run tests
        run: |
          cd ../boost-root
          export ADDRMD=${{matrix.address-model}}
          ./b2 -j3 libs/$LIBRARY/test toolset=${{matrix.toolset}} cxxstd=${{matrix.cxxstd}} ${ADDRMD:+address-model=$ADDRMD} variant=debug,release
  windows:
    strategy:
      fail-fast: false
      matrix:
        include:
          - 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,latest"
            addrmd: 32,64
            os: windows-2022
          - toolset: gcc
            cxxstd: "03,11,14,17,2a"
            addrmd: 64
            os: windows-2019
    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%
          cmd /c bootstrap
          b2 -d0 headers
      - name: Run tests
        shell: cmd
        run: |
          cd ../boost-root
          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/.travis.yml
+++ b/.travis.yml
@ -1,362 +0,0 @@
 # Copyright 2016-2019 Peter Dimov
 # Distributed under the Boost Software License, Version 1.0.
 # (See accompanying file LICENSE_1_0.txt or copy at http://boost.org/LICENSE_1_0.txt)
 language: cpp
 dist: xenial
 branches:
  only:
    - master
    - develop
    - /feature\/.*/
 env:
  matrix:
    - BOGUS_JOB=true
 matrix:
  exclude:
    - env: BOGUS_JOB=true
  include:
    - os: linux
      compiler: g++-4.4
      env: TOOLSET=gcc CXXSTD=98,0x
      addons:
        apt:
          packages:
            - g++-4.4
          sources:
            - ubuntu-toolchain-r-test
    - os: linux
      compiler: g++-4.6
      env: TOOLSET=gcc CXXSTD=03,0x
      addons:
        apt:
          packages:
            - g++-4.6
          sources:
            - ubuntu-toolchain-r-test
    - os: linux
      compiler: g++-4.7
      env: TOOLSET=gcc CXXSTD=03,11
      addons:
        apt:
          packages:
            - g++-4.7
          sources:
            - ubuntu-toolchain-r-test
    - os: linux
      compiler: g++-4.8
      env: TOOLSET=gcc CXXSTD=03,11
      addons:
        apt:
          packages:
            - g++-4.8
          sources:
            - ubuntu-toolchain-r-test
    - os: linux
      compiler: g++-4.9
      env: TOOLSET=gcc CXXSTD=03,11
      addons:
        apt:
          packages:
            - g++-4.9
          sources:
            - ubuntu-toolchain-r-test
    - os: linux
      compiler: g++-5
      env: TOOLSET=gcc CXXSTD=03,11,14,1z
      addons:
        apt:
          packages:
            - g++-5
          sources:
            - ubuntu-toolchain-r-test
    - os: linux
      compiler: g++-6
      env: TOOLSET=gcc CXXSTD=03,11,14,1z
      addons:
        apt:
          packages:
            - g++-6
          sources:
            - ubuntu-toolchain-r-test
    - os: linux
      compiler: g++-7
      env: TOOLSET=gcc CXXSTD=03,11,14,17
      addons:
        apt:
          packages:
            - g++-7
          sources:
            - ubuntu-toolchain-r-test
    - os: linux
      compiler: g++-8
      env: TOOLSET=gcc CXXSTD=03,11,14,17,2a
      addons:
        apt:
          packages:
            - g++-8
          sources:
            - ubuntu-toolchain-r-test
    - os: linux
      compiler: g++-9
      env: TOOLSET=gcc CXXSTD=03,11,14,17,2a
      addons:
        apt:
          packages:
            - g++-9
          sources:
            - ubuntu-toolchain-r-test
    - os: linux
      dist: bionic
      compiler: g++-10
      env: UBSAN=1 TOOLSET=gcc CXXSTD=03,11,14,17,2a UBSAN_OPTIONS=print_stacktrace=1 LINKFLAGS=-fuse-ld=gold
      addons:
        apt:
          packages:
            - g++-10
          sources:
            - ubuntu-toolchain-r-test
    - os: linux
      dist: trusty
      compiler: /usr/bin/clang++
      env: TOOLSET=clang CXXSTD=03,11
      addons:
        apt:
          packages:
            - clang-3.3
    - os: linux
      dist: trusty
      compiler: /usr/bin/clang++
      env: TOOLSET=clang CXXSTD=03,11
      addons:
        apt:
          packages:
            - clang-3.4
    - os: linux
      compiler: clang++-3.5
      env: TOOLSET=clang CXXSTD=03,11,14,1z
      addons:
        apt:
          packages:
            - clang-3.5
          sources:
            - ubuntu-toolchain-r-test
    - os: linux
      compiler: clang++-3.6
      env: TOOLSET=clang CXXSTD=03,11,14,1z
      addons:
        apt:
          packages:
            - clang-3.6
          sources:
            - ubuntu-toolchain-r-test
    - os: linux
      compiler: clang++-3.7
      env: TOOLSET=clang CXXSTD=03,11,14,1z
      addons:
        apt:
          packages:
            - clang-3.7
          sources:
            - ubuntu-toolchain-r-test
    - os: linux
      compiler: clang++-3.8
      env: TOOLSET=clang CXXSTD=03,11,14,1z
      addons:
        apt:
          packages:
            - clang-3.8
          sources:
            - ubuntu-toolchain-r-test
    - os: linux
      compiler: clang++-3.9
      env: TOOLSET=clang CXXSTD=03,11,14,1z
      addons:
        apt:
          packages:
            - clang-3.9
          sources:
            - ubuntu-toolchain-r-test
    - os: linux
      compiler: clang++-4.0
      env: TOOLSET=clang CXXSTD=03,11,14,1z
      addons:
        apt:
          packages:
            - clang-4.0
          sources:
            - ubuntu-toolchain-r-test
    - os: linux
      compiler: clang++-5.0
      env: TOOLSET=clang CXXSTD=03,11,14,1z
      addons:
        apt:
          packages:
            - clang-5.0
          sources:
            - ubuntu-toolchain-r-test
    - os: linux
      compiler: clang++-6.0
      env: TOOLSET=clang CXXSTD=03,11,14,17,2a
      addons:
        apt:
          packages:
            - clang-6.0
          sources:
            - ubuntu-toolchain-r-test
    - os: linux
      compiler: clang++-7
      env: TOOLSET=clang CXXSTD=03,11,14,17,2a
      addons:
        apt:
          packages:
            - clang-7
          sources:
            - ubuntu-toolchain-r-test
            - llvm-toolchain-xenial-7
    - os: linux
      compiler: clang++-8
      env: TOOLSET=clang CXXSTD=03,11,14,17,2a
      addons:
        apt:
          packages:
            - clang-8
          sources:
            - ubuntu-toolchain-r-test
            - llvm-toolchain-xenial-8
    - os: linux
      dist: bionic
      compiler: clang++-9
      env: TOOLSET=clang CXXSTD=03,11,14,17,2a
      addons:
        apt:
          packages:
            - clang-9
          sources:
            - ubuntu-toolchain-r-test
            - sourceline: 'deb https://apt.llvm.org/bionic/ llvm-toolchain-bionic-9 main'
              key_url: 'https://apt.llvm.org/llvm-snapshot.gpg.key'
    - os: linux
      dist: bionic
      compiler: clang++-10
      env: TOOLSET=clang CXXSTD=03,11,14,17,2a
      addons:
        apt:
          packages:
            - clang-10
          sources:
            - ubuntu-toolchain-r-test
            - sourceline: 'deb https://apt.llvm.org/bionic/ llvm-toolchain-bionic-10 main'
              key_url: 'https://apt.llvm.org/llvm-snapshot.gpg.key'
    - os: linux
      dist: bionic
      compiler: clang++-11
      env: TOOLSET=clang CXXSTD=03,11,14,17,2a
      addons:
        apt:
          packages:
            - clang-11
          sources:
            - ubuntu-toolchain-r-test
            - sourceline: 'deb https://apt.llvm.org/bionic/ llvm-toolchain-bionic-11 main'
              key_url: 'https://apt.llvm.org/llvm-snapshot.gpg.key'
    - os: linux
      dist: bionic
      compiler: clang++-12
      env: UBSAN=1 TOOLSET=clang CXXSTD=03,11,14,17,2a UBSAN_OPTIONS=print_stacktrace=1
      addons:
        apt:
          packages:
            - clang-12
          sources:
            - ubuntu-toolchain-r-test
            - sourceline: 'deb https://apt.llvm.org/bionic/ llvm-toolchain-bionic-12 main'
              key_url: 'https://apt.llvm.org/llvm-snapshot.gpg.key'
    - os: linux
      dist: trusty
      compiler: clang++-libc++
      env: UBSAN=1 TOOLSET=clang CXXSTD=03,11,14,1z UBSAN_OPTIONS=print_stacktrace=1
      addons:
        apt:
          packages:
            - libc++-dev
    - os: linux
      dist: bionic
      compiler: clang++-libc++
      env: UBSAN=1 TOOLSET=clang CXXSTD=03,11,14,17,2a UBSAN_OPTIONS=print_stacktrace=1
      addons:
        apt:
          packages:
            - libc++-dev
    - os: osx
      compiler: clang++
      env: UBSAN=1 TOOLSET=clang CXXSTD=03,11,14,1z UBSAN_OPTIONS=print_stacktrace=1
    - os: linux
      env: CMAKE_TEST=1
      script:
        - mkdir __build__ && cd __build__
        - cmake -DBOOST_ENABLE_CMAKE=1 -DBUILD_TESTING=ON -DBoost_VERBOSE=1 -DBOOST_INCLUDE_LIBRARIES=function ..
        - ctest --output-on-failure -R boost_function
    - os: linux
      env: CMAKE_SUBDIR_TEST=1
      script:
      - cd libs/function/test/cmake_subdir_test && mkdir __build__ && cd __build__
      - cmake ..
      - cmake --build .
      - cmake --build . --target check
 install:
  - BOOST_BRANCH=develop && [ "$TRAVIS_BRANCH" == "master" ] && BOOST_BRANCH=master || true
  - cd ..
  - git clone -b $BOOST_BRANCH https://github.com/boostorg/boost.git boost-root
  - cd boost-root
  - git submodule update --init tools/boostdep
  - cp -r $TRAVIS_BUILD_DIR/* libs/function
  - python tools/boostdep/depinst/depinst.py function
  - ./bootstrap.sh
  - ./b2 headers
 script:
  - |-
    echo "using $TOOLSET : : $TRAVIS_COMPILER ;" > ~/user-config.jam
  - ./b2 -j3 libs/function/test toolset=$TOOLSET cxxstd=$CXXSTD variant=debug,release ${UBSAN:+cxxflags=-fsanitize=undefined cxxflags=-fno-sanitize-recover=undefined linkflags=-fsanitize=undefined debug-symbols=on} ${LINKFLAGS:+linkflags=$LINKFLAGS}
 notifications:
  email:
    on_success: always
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@ -1,30 +0,0 @@
 # Generated by `boostdep --cmake function`
 # Copyright 2020, 2021 Peter Dimov
 # Distributed under the Boost Software License, Version 1.0.
 # https://www.boost.org/LICENSE_1_0.txt
 cmake_minimum_required(VERSION 3.5...3.20)
 project(boost_function VERSION "${BOOST_SUPERPROJECT_VERSION}" LANGUAGES CXX)
 add_library(boost_function INTERFACE)
 add_library(Boost::function ALIAS boost_function)
 target_include_directories(boost_function INTERFACE include)
 target_link_libraries(boost_function
  INTERFACE
    Boost::assert
    Boost::bind
    Boost::config
    Boost::core
    Boost::preprocessor
    Boost::throw_exception
    Boost::type_traits
 )
 if(BUILD_TESTING AND EXISTS "${CMAKE_CURRENT_SOURCE_DIR}/test/CMakeLists.txt")
  add_subdirectory(test)
 endif()
--- a/README.md
+++ b/README.md
@ -1,18 +0,0 @@
 # Boost.Function, a polymorphic function wrapper
 [Boost.Function](http://boost.org/libs/function), part of the
 [Boost C++ Libraries](http://boost.org), is the original implementation of the
 polymorphic function wrapper `boost::function`, which was eventually accepted
 into the C++11 standard as [`std::function`](https://en.cppreference.com/w/cpp/utility/functional/function).
 ## Currently supported compilers
 * g++ 4.8 or later
 * clang++ 3.9 or later
 * Visual Studio 2005-2022
 Tested on [Github Actions](https://github.com/boostorg/function/actions) and [Appveyor](https://ci.appveyor.com/project/pdimov/function/).
 ## License
 Distributed under the [Boost Software License, Version 1.0](http://boost.org/LICENSE_1_0.txt).
--- a/appveyor.yml
+++ b/appveyor.yml
@ -1,70 +0,0 @@
 # Copyright 2016-2019 Peter Dimov
 # Distributed under the Boost Software License, Version 1.0.
 # (See accompanying file LICENSE_1_0.txt or copy at http://boost.org/LICENSE_1_0.txt)
 version: 1.0.{build}-{branch}
 shallow_clone: true
 branches:
  only:
    - master
    - develop
    - /feature\/.*/
 environment:
  matrix:
    - APPVEYOR_BUILD_WORKER_IMAGE: Visual Studio 2015
      TOOLSET: msvc-10.0,msvc-11.0
      ADDRMD: 32
    - APPVEYOR_BUILD_WORKER_IMAGE: Visual Studio 2015
      TOOLSET: msvc-12.0,msvc-14.0
      ADDRMD: 32,64
    - APPVEYOR_BUILD_WORKER_IMAGE: Visual Studio 2017
      TOOLSET: msvc-14.1
      CXXSTD: 14,17
      ADDRMD: 32,64
    - APPVEYOR_BUILD_WORKER_IMAGE: Visual Studio 2017
      TOOLSET: clang-win
      CXXSTD: 14,17,latest
      ADDRMD: 64
    - APPVEYOR_BUILD_WORKER_IMAGE: Visual Studio 2019
      TOOLSET: clang-win
      CXXSTD: 14,17,latest
      ADDRMD: 64
    - APPVEYOR_BUILD_WORKER_IMAGE: Visual Studio 2015
      ADDPATH: C:\cygwin\bin;
      TOOLSET: gcc
      CXXSTD: 03,11,14,1z
    - APPVEYOR_BUILD_WORKER_IMAGE: Visual Studio 2015
      ADDPATH: C:\cygwin64\bin;
      TOOLSET: gcc
      CXXSTD: 03,11,14,1z
    - APPVEYOR_BUILD_WORKER_IMAGE: Visual Studio 2015
      ADDPATH: C:\mingw\bin;
      TOOLSET: gcc
      CXXSTD: 03,11,14,1z
    - APPVEYOR_BUILD_WORKER_IMAGE: Visual Studio 2015
      ADDPATH: C:\mingw-w64\x86_64-6.3.0-posix-seh-rt_v5-rev1\mingw64\bin;
      TOOLSET: gcc
      CXXSTD: 03,11,14,1z
 install:
  - set BOOST_BRANCH=develop
  - if "%APPVEYOR_REPO_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 %APPVEYOR_BUILD_FOLDER% libs\function\
  - python tools/boostdep/depinst/depinst.py function
  - cmd /c bootstrap
  - b2 -d0 headers
 build: off
 test_script:
  - PATH=%ADDPATH%%PATH%
  - if not "%CXXSTD%" == "" set CXXSTD=cxxstd=%CXXSTD%
  - if not "%ADDRMD%" == "" set ADDRMD=address-model=%ADDRMD%
  - b2 -j3 libs/function/test toolset=%TOOLSET% %CXXSTD% %ADDRMD% variant=debug,release embed-manifest-via=linker
--- a/doc/Jamfile.v2
+++ b/doc/Jamfile.v2
@ -3,7 +3,7 @@
 #   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)
-project function/doc ;
+project boost/doc ;
 import boostbook : boostbook ;
 boostbook function-doc 
@ -14,12 +14,3 @@ boostbook function-doc
        <format>pdf:<xsl:param>boost.url.prefix=http://www.boost.org/doc/libs/release/doc/html
    ;
 ###############################################################################
 alias boostdoc
    : function.xml
    :
    :
    : ;
 explicit boostdoc ;
 alias boostrelease ;
 explicit boostrelease ;
--- a/doc/history.xml
+++ b/doc/history.xml
@ -13,15 +13,6 @@
 <itemizedlist spacing="compact">
  <listitem><para><bold>Version 1.52.0</bold>: </para>
    <itemizedlist spacing="compact">
      <listitem><para>Move constructors and move assignment 
      operators added (only for compilers with C++11 rvalue 
      references support). Original patch
      contributed by Antony Polukhin.</para></listitem>
    </itemizedlist>
  </listitem>
  <listitem><para><bold>Version 1.37.0</bold>: </para>
    <itemizedlist spacing="compact">
      <listitem><para>Improved the performance of Boost.Function's
--- a/doc/reference.xml
+++ b/doc/reference.xml
@ -58,7 +58,7 @@
      <para>A function object <code>f</code> of
      type <code>F</code> is
      <emphasis>stateless</emphasis> if it is a function pointer or if
-      <code><classname>boost::is_stateless</classname>&lt;F&gt;</code>
+      <code><classname>boost::is_stateless</classname>&lt;T&gt;</code>
      is true. The construction of or copy to a Boost.Function object
      from a stateless function object will not cause exceptions to be
      thrown and will not allocate any storage.
@ -128,7 +128,7 @@
      <method name="target_type" cv="const">
        <type>const std::type_info&amp;</type>
-        <returns><simpara><code>typeid</code> of the target function object, or <code>typeid(void)</code> if <code>this-&gt;<methodname>empty</methodname>()</code>. Works even with RTTI off.</simpara></returns>
+        <returns><simpara><code>typeid</code> of the target function object, or <code>typeid(void)</code> if <code>this-&gt;<methodname>empty</methodname>()</code>.</simpara></returns>
        <throws><simpara>Will not throw.</simpara></throws>
      </method>
    </method-group>
@ -203,15 +203,6 @@
      <throws><simpara>Will not throw unless copying the target of <code>f</code> throws.</simpara></throws>
    </constructor>
    <constructor>
      <parameter name="f">
        <paramtype><classname>functionN</classname>&amp;&amp;</paramtype>
      </parameter>
      <requires><simpara>C++11 compatible compiler.</simpara></requires>
      <postconditions><simpara>Moves the value from <code>f</code> to <code>*this</code>. If the argument has its function object allocated on the heap, its buffer will be assigned to <code>*this</code> leaving argument empty.</simpara></postconditions>
      <throws><simpara>Will not throw unless argument has its function object allocated not on the heap and copying the target of <code>f</code> throws.</simpara></throws>
    </constructor>
    <constructor>
      <template>
        <template-type-parameter name="F"/>
@ -245,15 +236,6 @@
      </parameter>
      <postconditions><simpara>If copy construction does not throw, <code>*this</code> targets a copy of <code>f</code>'s target, if it has one, or is empty if <code>f.<methodname>empty</methodname>()</code>. If copy construction does throw, <code>this-&gt;<methodname>empty</methodname>()</code>.</simpara></postconditions>
    </copy-assignment>
    <copy-assignment>
      <parameter name="f">
        <paramtype><classname>functionN</classname>&amp;&amp;</paramtype>
      </parameter>
      <requires><simpara>C++11 compatible compiler.</simpara></requires>
      <postconditions><simpara>Moves the value from <code>f</code> to <code>*this</code>. If the argument has its function object allocated on the heap, its buffer will be assigned to <code>*this</code> leaving argument empty.</simpara></postconditions>
      <throws><simpara>Will not throw unless argument has its function object allocated not on the heap and copying the target of <code>f</code> throws.</simpara></throws>
    </copy-assignment>
    <method-group name="modifiers">
      <method name="swap">
@ -625,16 +607,7 @@
      <postconditions><simpara>Contains a copy of the <code>f</code>'s target, if it has one, or is empty if <code>f.<methodname>empty</methodname>()</code>.</simpara></postconditions>
      <throws><simpara>Will not throw unless copying the target of <code>f</code> throws.</simpara></throws>
    </constructor>
-        
+
    <constructor>
      <parameter name="f">
        <paramtype><classname>functionN</classname>&amp;&amp;</paramtype>
      </parameter>
      <requires><simpara>C++11 compatible compiler.</simpara></requires>
      <postconditions><simpara>Moves the value from <code>f</code> to <code>*this</code>. If the argument has its function object allocated on the heap, its buffer will be assigned to <code>*this</code> leaving argument empty.</simpara></postconditions>
      <throws><simpara>Will not throw unless argument has its function object allocated not on the heap and copying the target of <code>f</code> throws.</simpara></throws>
    </constructor>
    <constructor>
      <parameter name="f">
        <paramtype>const <classname>function</classname>&amp;</paramtype>
@ -643,15 +616,6 @@
      <throws><simpara>Will not throw unless copying the target of <code>f</code> throws.</simpara></throws>
    </constructor>
    <constructor>
      <parameter name="f">
        <paramtype><classname>function</classname>&amp;&amp;</paramtype>
      </parameter>
      <requires><simpara>C++11 compatible compiler.</simpara></requires>
      <postconditions><simpara>Moves the value from <code>f</code> to <code>*this</code>. If the argument has its function object allocated on the heap, its buffer will be assigned to <code>*this</code> leaving argument empty.</simpara></postconditions>
      <throws><simpara>Will not throw unless argument has its function object allocated not on the heap and copying the target of <code>f</code> throws.</simpara></throws>
    </constructor>
    <constructor>
      <template>
        <template-type-parameter name="F"/>
@ -681,19 +645,10 @@
    <copy-assignment>
      <parameter name="f">
-        <paramtype>const <classname>functionN</classname>&amp;</paramtype>
+        <paramtype>const <classname>function</classname>&amp;</paramtype>
      </parameter>
      <postconditions><simpara>If copy construction does not throw, <code>*this</code> targets a copy of <code>f</code>'s target, if it has one, or is empty if <code>f.<methodname>empty</methodname>()</code>. If copy construction does throw, <code>this-&gt;<methodname>empty</methodname>()</code>.</simpara></postconditions>
    </copy-assignment>
    <copy-assignment>
      <parameter name="f">
        <paramtype><classname>functionN</classname>&amp;&amp;</paramtype>
      </parameter>
      <requires><simpara>C++11 compatible compiler.</simpara></requires>
      <postconditions><simpara>Moves the value from <code>f</code> to <code>*this</code>. If the argument has its function object allocated on the heap, its buffer will be assigned to <code>*this</code> leaving argument empty.</simpara></postconditions>
      <throws><simpara>Will not throw unless argument has its function object allocated not on the heap and copying the target of <code>f</code> throws.</simpara></throws>
    </copy-assignment>
    <copy-assignment>
      <parameter name="f">
@ -702,15 +657,6 @@
      <postconditions><simpara>If copy construction of the target of <code>f</code> does not throw, <code>*this</code> targets a copy of <code>f</code>'s target, if it has one, or is empty if <code>f.<methodname>empty</methodname>()</code>. </simpara></postconditions>
      <throws><simpara>Will not throw when the target of <code>f</code> is a stateless function object or a reference to the function object. If copy construction does throw, <code>this-&gt;<methodname>empty</methodname>()</code>.</simpara></throws>
    </copy-assignment>
    <copy-assignment>
      <parameter name="f">
        <paramtype><classname>function</classname>&amp;&amp;</paramtype>
      </parameter>
      <requires><simpara>C++11 compatible compiler.</simpara></requires>
      <postconditions><simpara>Moves the value from <code>f</code> to <code>*this</code>. If the argument has its function object allocated on the heap, its buffer will be assigned to <code>*this</code> leaving argument empty.</simpara></postconditions>
      <throws><simpara>Will not throw unless argument has its function object allocated not on the heap and copying the target of <code>f</code> throws.</simpara></throws>
    </copy-assignment>
    <method-group name="modifiers">
      <method name="swap">
--- a/example/Jamfile
+++ b/example/Jamfile
@ -1,14 +0,0 @@
 # Boost.Function Library example Jamfile
 #
 # Copyright (c) 2008 James E. King III
 #
 # 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
 import ../../config/checks/config : requires ;
 import testing ;
 run bind1st.cpp : : : [ requires cxx98_binders ] ;
 run int_div.cpp ;
 run sum_avg.cpp ;
--- a/include/boost/function.hpp
+++ b/include/boost/function.hpp
@ -10,20 +10,14 @@
 // William Kempf, Jesse Jones and Karl Nelson were all very helpful in the
 // design of this library.
 #ifndef BOOST_FUNCTION_MAX_ARGS
 #  define BOOST_FUNCTION_MAX_ARGS 10
 #endif // BOOST_FUNCTION_MAX_ARGS
 #if !defined(BOOST_FUNCTION_MAX_ARGS_DEFINED) || (BOOST_FUNCTION_MAX_ARGS_DEFINED != BOOST_FUNCTION_MAX_ARGS)
 #if !defined(BOOST_FUNCTION_MAX_ARGS_DEFINED)
 #define BOOST_FUNCTION_MAX_ARGS_DEFINED 0
 #endif
 #include <functional> // unary_function, binary_function
 #include <boost/preprocessor/iterate.hpp>
-#include <boost/config/workaround.hpp>
+#include <boost/detail/workaround.hpp>
 #ifndef BOOST_FUNCTION_MAX_ARGS
 #  define BOOST_FUNCTION_MAX_ARGS 10
 #endif // BOOST_FUNCTION_MAX_ARGS
 // Include the prologue here so that the use of file-level iteration
 // in anything that may be included by function_template.hpp doesn't break
@ -70,7 +64,3 @@
 #  include BOOST_PP_ITERATE()
 #  undef BOOST_PP_ITERATION_PARAMS_1
 #endif
 #include <boost/function/detail/epilogue.hpp>
 #endif // !defined(BOOST_FUNCTION_MAX_ARGS_DEFINED) || (BOOST_FUNCTION_MAX_ARGS_DEFINED != BOOST_FUNCTION_MAX_ARGS)
--- a/include/boost/function/detail/epilogue.hpp
+++ b/include/boost/function/detail/epilogue.hpp
@ -1,39 +0,0 @@
 // Boost.Function library
 #ifndef BOOST_FUNCTION_EPILOGUE_HPP
 #define BOOST_FUNCTION_EPILOGUE_HPP
 // Copyright 2023 Peter Dimov
 // Distributed under the Boost Software License, Version 1.0.
 // https://www.boost.org/LICENSE_1_0.txt
 // Resolve C++20 issue with fn == bind(...)
 // https://github.com/boostorg/function/issues/45
 #if !defined(BOOST_FUNCTION_NO_FUNCTION_TYPE_SYNTAX)
 namespace boost
 {
 namespace _bi
 {
 template<class R, class F, class L> class bind_t;
 } // namespace _bi
 template<class S, class R, class F, class L> bool operator==( function<S> const& f, _bi::bind_t<R, F, L> const& b )
 {
    return f.contains( b );
 }
 template<class S, class R, class F, class L> bool operator!=( function<S> const& f, _bi::bind_t<R, F, L> const& b )
 {
    return !f.contains( b );
 }
 } // namespace boost
 #endif // #if !defined(BOOST_FUNCTION_NO_FUNCTION_TYPE_SYNTAX)
 #endif // #ifndef BOOST_FUNCTION_EPILOGUE_HPP
--- a/include/boost/function/detail/gen_maybe_include.pl
+++ b/include/boost/function/detail/gen_maybe_include.pl
@ -27,8 +27,6 @@ for($on_arg = 0; $on_arg <= $max_args; ++$on_arg) {
 	print OUT "#elif";
    }
    print OUT " BOOST_FUNCTION_NUM_ARGS == $on_arg\n";
    print OUT "#  undef BOOST_FUNCTION_MAX_ARGS_DEFINED\n";
    print OUT "#  define BOOST_FUNCTION_MAX_ARGS_DEFINED $on_arg\n";
    print OUT "#  ifndef BOOST_FUNCTION_$on_arg\n";
    print OUT "#    define BOOST_FUNCTION_$on_arg\n";
    print OUT "#    include <boost/function/function_template.hpp>\n";
--- a/include/boost/function/detail/maybe_include.hpp
+++ b/include/boost/function/detail/maybe_include.hpp
@ -8,358 +8,256 @@
 // For more information, see http://www.boost.org
 #if BOOST_FUNCTION_NUM_ARGS == 0
 #  undef BOOST_FUNCTION_MAX_ARGS_DEFINED
 #  define BOOST_FUNCTION_MAX_ARGS_DEFINED 0
 #  ifndef BOOST_FUNCTION_0
 #    define BOOST_FUNCTION_0
 #    include <boost/function/function_template.hpp>
 #  endif
 #elif BOOST_FUNCTION_NUM_ARGS == 1
 #  undef BOOST_FUNCTION_MAX_ARGS_DEFINED
 #  define BOOST_FUNCTION_MAX_ARGS_DEFINED 1
 #  ifndef BOOST_FUNCTION_1
 #    define BOOST_FUNCTION_1
 #    include <boost/function/function_template.hpp>
 #  endif
 #elif BOOST_FUNCTION_NUM_ARGS == 2
 #  undef BOOST_FUNCTION_MAX_ARGS_DEFINED
 #  define BOOST_FUNCTION_MAX_ARGS_DEFINED 2
 #  ifndef BOOST_FUNCTION_2
 #    define BOOST_FUNCTION_2
 #    include <boost/function/function_template.hpp>
 #  endif
 #elif BOOST_FUNCTION_NUM_ARGS == 3
 #  undef BOOST_FUNCTION_MAX_ARGS_DEFINED
 #  define BOOST_FUNCTION_MAX_ARGS_DEFINED 3
 #  ifndef BOOST_FUNCTION_3
 #    define BOOST_FUNCTION_3
 #    include <boost/function/function_template.hpp>
 #  endif
 #elif BOOST_FUNCTION_NUM_ARGS == 4
 #  undef BOOST_FUNCTION_MAX_ARGS_DEFINED
 #  define BOOST_FUNCTION_MAX_ARGS_DEFINED 4
 #  ifndef BOOST_FUNCTION_4
 #    define BOOST_FUNCTION_4
 #    include <boost/function/function_template.hpp>
 #  endif
 #elif BOOST_FUNCTION_NUM_ARGS == 5
 #  undef BOOST_FUNCTION_MAX_ARGS_DEFINED
 #  define BOOST_FUNCTION_MAX_ARGS_DEFINED 5
 #  ifndef BOOST_FUNCTION_5
 #    define BOOST_FUNCTION_5
 #    include <boost/function/function_template.hpp>
 #  endif
 #elif BOOST_FUNCTION_NUM_ARGS == 6
 #  undef BOOST_FUNCTION_MAX_ARGS_DEFINED
 #  define BOOST_FUNCTION_MAX_ARGS_DEFINED 6
 #  ifndef BOOST_FUNCTION_6
 #    define BOOST_FUNCTION_6
 #    include <boost/function/function_template.hpp>
 #  endif
 #elif BOOST_FUNCTION_NUM_ARGS == 7
 #  undef BOOST_FUNCTION_MAX_ARGS_DEFINED
 #  define BOOST_FUNCTION_MAX_ARGS_DEFINED 7
 #  ifndef BOOST_FUNCTION_7
 #    define BOOST_FUNCTION_7
 #    include <boost/function/function_template.hpp>
 #  endif
 #elif BOOST_FUNCTION_NUM_ARGS == 8
 #  undef BOOST_FUNCTION_MAX_ARGS_DEFINED
 #  define BOOST_FUNCTION_MAX_ARGS_DEFINED 8
 #  ifndef BOOST_FUNCTION_8
 #    define BOOST_FUNCTION_8
 #    include <boost/function/function_template.hpp>
 #  endif
 #elif BOOST_FUNCTION_NUM_ARGS == 9
 #  undef BOOST_FUNCTION_MAX_ARGS_DEFINED
 #  define BOOST_FUNCTION_MAX_ARGS_DEFINED 9
 #  ifndef BOOST_FUNCTION_9
 #    define BOOST_FUNCTION_9
 #    include <boost/function/function_template.hpp>
 #  endif
 #elif BOOST_FUNCTION_NUM_ARGS == 10
 #  undef BOOST_FUNCTION_MAX_ARGS_DEFINED
 #  define BOOST_FUNCTION_MAX_ARGS_DEFINED 10
 #  ifndef BOOST_FUNCTION_10
 #    define BOOST_FUNCTION_10
 #    include <boost/function/function_template.hpp>
 #  endif
 #elif BOOST_FUNCTION_NUM_ARGS == 11
 #  undef BOOST_FUNCTION_MAX_ARGS_DEFINED
 #  define BOOST_FUNCTION_MAX_ARGS_DEFINED 11
 #  ifndef BOOST_FUNCTION_11
 #    define BOOST_FUNCTION_11
 #    include <boost/function/function_template.hpp>
 #  endif
 #elif BOOST_FUNCTION_NUM_ARGS == 12
 #  undef BOOST_FUNCTION_MAX_ARGS_DEFINED
 #  define BOOST_FUNCTION_MAX_ARGS_DEFINED 12
 #  ifndef BOOST_FUNCTION_12
 #    define BOOST_FUNCTION_12
 #    include <boost/function/function_template.hpp>
 #  endif
 #elif BOOST_FUNCTION_NUM_ARGS == 13
 #  undef BOOST_FUNCTION_MAX_ARGS_DEFINED
 #  define BOOST_FUNCTION_MAX_ARGS_DEFINED 13
 #  ifndef BOOST_FUNCTION_13
 #    define BOOST_FUNCTION_13
 #    include <boost/function/function_template.hpp>
 #  endif
 #elif BOOST_FUNCTION_NUM_ARGS == 14
 #  undef BOOST_FUNCTION_MAX_ARGS_DEFINED
 #  define BOOST_FUNCTION_MAX_ARGS_DEFINED 14
 #  ifndef BOOST_FUNCTION_14
 #    define BOOST_FUNCTION_14
 #    include <boost/function/function_template.hpp>
 #  endif
 #elif BOOST_FUNCTION_NUM_ARGS == 15
 #  undef BOOST_FUNCTION_MAX_ARGS_DEFINED
 #  define BOOST_FUNCTION_MAX_ARGS_DEFINED 15
 #  ifndef BOOST_FUNCTION_15
 #    define BOOST_FUNCTION_15
 #    include <boost/function/function_template.hpp>
 #  endif
 #elif BOOST_FUNCTION_NUM_ARGS == 16
 #  undef BOOST_FUNCTION_MAX_ARGS_DEFINED
 #  define BOOST_FUNCTION_MAX_ARGS_DEFINED 16
 #  ifndef BOOST_FUNCTION_16
 #    define BOOST_FUNCTION_16
 #    include <boost/function/function_template.hpp>
 #  endif
 #elif BOOST_FUNCTION_NUM_ARGS == 17
 #  undef BOOST_FUNCTION_MAX_ARGS_DEFINED
 #  define BOOST_FUNCTION_MAX_ARGS_DEFINED 17
 #  ifndef BOOST_FUNCTION_17
 #    define BOOST_FUNCTION_17
 #    include <boost/function/function_template.hpp>
 #  endif
 #elif BOOST_FUNCTION_NUM_ARGS == 18
 #  undef BOOST_FUNCTION_MAX_ARGS_DEFINED
 #  define BOOST_FUNCTION_MAX_ARGS_DEFINED 18
 #  ifndef BOOST_FUNCTION_18
 #    define BOOST_FUNCTION_18
 #    include <boost/function/function_template.hpp>
 #  endif
 #elif BOOST_FUNCTION_NUM_ARGS == 19
 #  undef BOOST_FUNCTION_MAX_ARGS_DEFINED
 #  define BOOST_FUNCTION_MAX_ARGS_DEFINED 19
 #  ifndef BOOST_FUNCTION_19
 #    define BOOST_FUNCTION_19
 #    include <boost/function/function_template.hpp>
 #  endif
 #elif BOOST_FUNCTION_NUM_ARGS == 20
 #  undef BOOST_FUNCTION_MAX_ARGS_DEFINED
 #  define BOOST_FUNCTION_MAX_ARGS_DEFINED 20
 #  ifndef BOOST_FUNCTION_20
 #    define BOOST_FUNCTION_20
 #    include <boost/function/function_template.hpp>
 #  endif
 #elif BOOST_FUNCTION_NUM_ARGS == 21
 #  undef BOOST_FUNCTION_MAX_ARGS_DEFINED
 #  define BOOST_FUNCTION_MAX_ARGS_DEFINED 21
 #  ifndef BOOST_FUNCTION_21
 #    define BOOST_FUNCTION_21
 #    include <boost/function/function_template.hpp>
 #  endif
 #elif BOOST_FUNCTION_NUM_ARGS == 22
 #  undef BOOST_FUNCTION_MAX_ARGS_DEFINED
 #  define BOOST_FUNCTION_MAX_ARGS_DEFINED 22
 #  ifndef BOOST_FUNCTION_22
 #    define BOOST_FUNCTION_22
 #    include <boost/function/function_template.hpp>
 #  endif
 #elif BOOST_FUNCTION_NUM_ARGS == 23
 #  undef BOOST_FUNCTION_MAX_ARGS_DEFINED
 #  define BOOST_FUNCTION_MAX_ARGS_DEFINED 23
 #  ifndef BOOST_FUNCTION_23
 #    define BOOST_FUNCTION_23
 #    include <boost/function/function_template.hpp>
 #  endif
 #elif BOOST_FUNCTION_NUM_ARGS == 24
 #  undef BOOST_FUNCTION_MAX_ARGS_DEFINED
 #  define BOOST_FUNCTION_MAX_ARGS_DEFINED 24
 #  ifndef BOOST_FUNCTION_24
 #    define BOOST_FUNCTION_24
 #    include <boost/function/function_template.hpp>
 #  endif
 #elif BOOST_FUNCTION_NUM_ARGS == 25
 #  undef BOOST_FUNCTION_MAX_ARGS_DEFINED
 #  define BOOST_FUNCTION_MAX_ARGS_DEFINED 25
 #  ifndef BOOST_FUNCTION_25
 #    define BOOST_FUNCTION_25
 #    include <boost/function/function_template.hpp>
 #  endif
 #elif BOOST_FUNCTION_NUM_ARGS == 26
 #  undef BOOST_FUNCTION_MAX_ARGS_DEFINED
 #  define BOOST_FUNCTION_MAX_ARGS_DEFINED 26
 #  ifndef BOOST_FUNCTION_26
 #    define BOOST_FUNCTION_26
 #    include <boost/function/function_template.hpp>
 #  endif
 #elif BOOST_FUNCTION_NUM_ARGS == 27
 #  undef BOOST_FUNCTION_MAX_ARGS_DEFINED
 #  define BOOST_FUNCTION_MAX_ARGS_DEFINED 27
 #  ifndef BOOST_FUNCTION_27
 #    define BOOST_FUNCTION_27
 #    include <boost/function/function_template.hpp>
 #  endif
 #elif BOOST_FUNCTION_NUM_ARGS == 28
 #  undef BOOST_FUNCTION_MAX_ARGS_DEFINED
 #  define BOOST_FUNCTION_MAX_ARGS_DEFINED 28
 #  ifndef BOOST_FUNCTION_28
 #    define BOOST_FUNCTION_28
 #    include <boost/function/function_template.hpp>
 #  endif
 #elif BOOST_FUNCTION_NUM_ARGS == 29
 #  undef BOOST_FUNCTION_MAX_ARGS_DEFINED
 #  define BOOST_FUNCTION_MAX_ARGS_DEFINED 29
 #  ifndef BOOST_FUNCTION_29
 #    define BOOST_FUNCTION_29
 #    include <boost/function/function_template.hpp>
 #  endif
 #elif BOOST_FUNCTION_NUM_ARGS == 30
 #  undef BOOST_FUNCTION_MAX_ARGS_DEFINED
 #  define BOOST_FUNCTION_MAX_ARGS_DEFINED 30
 #  ifndef BOOST_FUNCTION_30
 #    define BOOST_FUNCTION_30
 #    include <boost/function/function_template.hpp>
 #  endif
 #elif BOOST_FUNCTION_NUM_ARGS == 31
 #  undef BOOST_FUNCTION_MAX_ARGS_DEFINED
 #  define BOOST_FUNCTION_MAX_ARGS_DEFINED 31
 #  ifndef BOOST_FUNCTION_31
 #    define BOOST_FUNCTION_31
 #    include <boost/function/function_template.hpp>
 #  endif
 #elif BOOST_FUNCTION_NUM_ARGS == 32
 #  undef BOOST_FUNCTION_MAX_ARGS_DEFINED
 #  define BOOST_FUNCTION_MAX_ARGS_DEFINED 32
 #  ifndef BOOST_FUNCTION_32
 #    define BOOST_FUNCTION_32
 #    include <boost/function/function_template.hpp>
 #  endif
 #elif BOOST_FUNCTION_NUM_ARGS == 33
 #  undef BOOST_FUNCTION_MAX_ARGS_DEFINED
 #  define BOOST_FUNCTION_MAX_ARGS_DEFINED 33
 #  ifndef BOOST_FUNCTION_33
 #    define BOOST_FUNCTION_33
 #    include <boost/function/function_template.hpp>
 #  endif
 #elif BOOST_FUNCTION_NUM_ARGS == 34
 #  undef BOOST_FUNCTION_MAX_ARGS_DEFINED
 #  define BOOST_FUNCTION_MAX_ARGS_DEFINED 34
 #  ifndef BOOST_FUNCTION_34
 #    define BOOST_FUNCTION_34
 #    include <boost/function/function_template.hpp>
 #  endif
 #elif BOOST_FUNCTION_NUM_ARGS == 35
 #  undef BOOST_FUNCTION_MAX_ARGS_DEFINED
 #  define BOOST_FUNCTION_MAX_ARGS_DEFINED 35
 #  ifndef BOOST_FUNCTION_35
 #    define BOOST_FUNCTION_35
 #    include <boost/function/function_template.hpp>
 #  endif
 #elif BOOST_FUNCTION_NUM_ARGS == 36
 #  undef BOOST_FUNCTION_MAX_ARGS_DEFINED
 #  define BOOST_FUNCTION_MAX_ARGS_DEFINED 36
 #  ifndef BOOST_FUNCTION_36
 #    define BOOST_FUNCTION_36
 #    include <boost/function/function_template.hpp>
 #  endif
 #elif BOOST_FUNCTION_NUM_ARGS == 37
 #  undef BOOST_FUNCTION_MAX_ARGS_DEFINED
 #  define BOOST_FUNCTION_MAX_ARGS_DEFINED 37
 #  ifndef BOOST_FUNCTION_37
 #    define BOOST_FUNCTION_37
 #    include <boost/function/function_template.hpp>
 #  endif
 #elif BOOST_FUNCTION_NUM_ARGS == 38
 #  undef BOOST_FUNCTION_MAX_ARGS_DEFINED
 #  define BOOST_FUNCTION_MAX_ARGS_DEFINED 38
 #  ifndef BOOST_FUNCTION_38
 #    define BOOST_FUNCTION_38
 #    include <boost/function/function_template.hpp>
 #  endif
 #elif BOOST_FUNCTION_NUM_ARGS == 39
 #  undef BOOST_FUNCTION_MAX_ARGS_DEFINED
 #  define BOOST_FUNCTION_MAX_ARGS_DEFINED 39
 #  ifndef BOOST_FUNCTION_39
 #    define BOOST_FUNCTION_39
 #    include <boost/function/function_template.hpp>
 #  endif
 #elif BOOST_FUNCTION_NUM_ARGS == 40
 #  undef BOOST_FUNCTION_MAX_ARGS_DEFINED
 #  define BOOST_FUNCTION_MAX_ARGS_DEFINED 40
 #  ifndef BOOST_FUNCTION_40
 #    define BOOST_FUNCTION_40
 #    include <boost/function/function_template.hpp>
 #  endif
 #elif BOOST_FUNCTION_NUM_ARGS == 41
 #  undef BOOST_FUNCTION_MAX_ARGS_DEFINED
 #  define BOOST_FUNCTION_MAX_ARGS_DEFINED 41
 #  ifndef BOOST_FUNCTION_41
 #    define BOOST_FUNCTION_41
 #    include <boost/function/function_template.hpp>
 #  endif
 #elif BOOST_FUNCTION_NUM_ARGS == 42
 #  undef BOOST_FUNCTION_MAX_ARGS_DEFINED
 #  define BOOST_FUNCTION_MAX_ARGS_DEFINED 42
 #  ifndef BOOST_FUNCTION_42
 #    define BOOST_FUNCTION_42
 #    include <boost/function/function_template.hpp>
 #  endif
 #elif BOOST_FUNCTION_NUM_ARGS == 43
 #  undef BOOST_FUNCTION_MAX_ARGS_DEFINED
 #  define BOOST_FUNCTION_MAX_ARGS_DEFINED 43
 #  ifndef BOOST_FUNCTION_43
 #    define BOOST_FUNCTION_43
 #    include <boost/function/function_template.hpp>
 #  endif
 #elif BOOST_FUNCTION_NUM_ARGS == 44
 #  undef BOOST_FUNCTION_MAX_ARGS_DEFINED
 #  define BOOST_FUNCTION_MAX_ARGS_DEFINED 44
 #  ifndef BOOST_FUNCTION_44
 #    define BOOST_FUNCTION_44
 #    include <boost/function/function_template.hpp>
 #  endif
 #elif BOOST_FUNCTION_NUM_ARGS == 45
 #  undef BOOST_FUNCTION_MAX_ARGS_DEFINED
 #  define BOOST_FUNCTION_MAX_ARGS_DEFINED 45
 #  ifndef BOOST_FUNCTION_45
 #    define BOOST_FUNCTION_45
 #    include <boost/function/function_template.hpp>
 #  endif
 #elif BOOST_FUNCTION_NUM_ARGS == 46
 #  undef BOOST_FUNCTION_MAX_ARGS_DEFINED
 #  define BOOST_FUNCTION_MAX_ARGS_DEFINED 46
 #  ifndef BOOST_FUNCTION_46
 #    define BOOST_FUNCTION_46
 #    include <boost/function/function_template.hpp>
 #  endif
 #elif BOOST_FUNCTION_NUM_ARGS == 47
 #  undef BOOST_FUNCTION_MAX_ARGS_DEFINED
 #  define BOOST_FUNCTION_MAX_ARGS_DEFINED 47
 #  ifndef BOOST_FUNCTION_47
 #    define BOOST_FUNCTION_47
 #    include <boost/function/function_template.hpp>
 #  endif
 #elif BOOST_FUNCTION_NUM_ARGS == 48
 #  undef BOOST_FUNCTION_MAX_ARGS_DEFINED
 #  define BOOST_FUNCTION_MAX_ARGS_DEFINED 48
 #  ifndef BOOST_FUNCTION_48
 #    define BOOST_FUNCTION_48
 #    include <boost/function/function_template.hpp>
 #  endif
 #elif BOOST_FUNCTION_NUM_ARGS == 49
 #  undef BOOST_FUNCTION_MAX_ARGS_DEFINED
 #  define BOOST_FUNCTION_MAX_ARGS_DEFINED 49
 #  ifndef BOOST_FUNCTION_49
 #    define BOOST_FUNCTION_49
 #    include <boost/function/function_template.hpp>
 #  endif
 #elif BOOST_FUNCTION_NUM_ARGS == 50
 #  undef BOOST_FUNCTION_MAX_ARGS_DEFINED
 #  define BOOST_FUNCTION_MAX_ARGS_DEFINED 50
 #  ifndef BOOST_FUNCTION_50
 #    define BOOST_FUNCTION_50
 #    include <boost/function/function_template.hpp>
--- a/include/boost/function/detail/prologue.hpp
+++ b/include/boost/function/detail/prologue.hpp
@ -9,7 +9,6 @@
 #ifndef BOOST_FUNCTION_PROLOGUE_HPP
 #define BOOST_FUNCTION_PROLOGUE_HPP
 #  include <boost/function/detail/requires_cxx11.hpp>
 #  include <cassert>
 #  include <algorithm>
 #  include <boost/config/no_tr1/functional.hpp> // unary_function, binary_function
--- a/include/boost/function/detail/requires_cxx11.hpp
+++ b/include/boost/function/detail/requires_cxx11.hpp
@ -1,22 +0,0 @@
 #ifndef BOOST_FUNCTION_DETAIL_REQUIRES_CXX11_HPP_INCLUDED
 #define BOOST_FUNCTION_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.Function 1.82 and will be removed in Boost.Function 1.85.")
 #endif
 #endif // #ifndef BOOST_FUNCTION_DETAIL_REQUIRES_CXX11_HPP_INCLUDED
--- a/include/boost/function/function_base.hpp
+++ b/include/boost/function/function_base.hpp
@ -11,45 +11,80 @@
 #ifndef BOOST_FUNCTION_BASE_HEADER
 #define BOOST_FUNCTION_BASE_HEADER
-#include <boost/function/function_fwd.hpp>
+#include <stdexcept>
-#include <boost/function_equal.hpp>
+#include <string>
-#include <boost/core/typeinfo.hpp>
+#include <memory>
-#include <boost/core/ref.hpp>
+#include <new>
 #include <boost/config.hpp>
 #include <boost/detail/sp_typeinfo.hpp>
 #include <boost/assert.hpp>
 #include <boost/integer.hpp>
 #include <boost/type_traits/has_trivial_copy.hpp>
 #include <boost/type_traits/has_trivial_destructor.hpp>
 #include <boost/type_traits/is_const.hpp>
 #include <boost/type_traits/is_integral.hpp>
 #include <boost/type_traits/is_volatile.hpp>
 #include <boost/type_traits/composite_traits.hpp>
-#include <boost/type_traits/conditional.hpp>
+#include <boost/type_traits/ice.hpp>
 #include <boost/ref.hpp>
 #include <boost/mpl/if.hpp>
 #include <boost/detail/workaround.hpp>
 #include <boost/type_traits/alignment_of.hpp>
-#include <boost/type_traits/enable_if.hpp>
+#ifndef BOOST_NO_SFINAE
-#include <boost/type_traits/integral_constant.hpp>
+#  include "boost/utility/enable_if.hpp"
-#include <boost/type_traits/is_function.hpp>
+#else
-#include <boost/assert.hpp>
+#  include "boost/mpl/bool.hpp"
-#include <boost/config.hpp>
+#endif
-#include <boost/config/workaround.hpp>
+#include <boost/function_equal.hpp>
-#include <stdexcept>
+#include <boost/function/function_fwd.hpp>
 #include <string>
 #include <memory>
 #include <new>
 #if defined(BOOST_MSVC)
 #   pragma warning( push )
 #   pragma warning( disable : 4793 ) // complaint about native code generation
 #   pragma warning( disable : 4127 ) // "conditional expression is constant"
 #endif       
 // Define BOOST_FUNCTION_STD_NS to the namespace that contains type_info.
 #ifdef BOOST_NO_STD_TYPEINFO
 // Embedded VC++ does not have type_info in namespace std
 #  define BOOST_FUNCTION_STD_NS
 #else
 #  define BOOST_FUNCTION_STD_NS std
 #endif
-#if defined(__ICL) && __ICL <= 600 || defined(__MWERKS__) && __MWERKS__ < 0x2406 && !defined(BOOST_STRICT_CONFIG)
+// Borrowed from Boost.Python library: determines the cases where we
 // need to use std::type_info::name to compare instead of operator==.
 #if defined( BOOST_NO_TYPEID )
 #  define BOOST_FUNCTION_COMPARE_TYPE_ID(X,Y) ((X)==(Y))
 #elif (defined(__GNUC__) && __GNUC__ >= 3) \
 || defined(_AIX) \
 || (   defined(__sgi) && defined(__host_mips))
 #  include <cstring>
 #  define BOOST_FUNCTION_COMPARE_TYPE_ID(X,Y) \
     (std::strcmp((X).name(),(Y).name()) == 0)
 # else
 #  define BOOST_FUNCTION_COMPARE_TYPE_ID(X,Y) ((X)==(Y))
 #endif
 #if defined(BOOST_MSVC) && BOOST_MSVC <= 1300 || defined(__ICL) && __ICL <= 600 || defined(__MWERKS__) && __MWERKS__ < 0x2406 && !defined(BOOST_STRICT_CONFIG)
 #  define BOOST_FUNCTION_TARGET_FIX(x) x
 #else
 #  define BOOST_FUNCTION_TARGET_FIX(x)
-#endif // __ICL etc
+#endif // not MSVC
 #if !BOOST_WORKAROUND(__BORLANDC__, < 0x5A0)
 #  define BOOST_FUNCTION_ENABLE_IF_NOT_INTEGRAL(Functor,Type)              \
-      typename ::boost::enable_if_<          \
+      typename ::boost::enable_if_c<(::boost::type_traits::ice_not<          \
-                           !(::boost::is_integral<Functor>::value), \
+                            (::boost::is_integral<Functor>::value)>::value), \
                           Type>::type
 #else
 // BCC doesn't recognize this depends on a template argument and complains
 // about the use of 'typename'
 #  define BOOST_FUNCTION_ENABLE_IF_NOT_INTEGRAL(Functor,Type)     \
      ::boost::enable_if_c<(::boost::type_traits::ice_not<          \
                   (::boost::is_integral<Functor>::value)>::value), \
                       Type>::type
 #endif
 namespace boost {
  namespace detail {
@ -62,16 +97,15 @@ namespace boost {
       * object pointers, and a structure that resembles a bound
       * member function pointer.
       */
-      union function_buffer_members
+      union function_buffer
      {
        // For pointers to function objects
-        typedef void* obj_ptr_t;
+        mutable void* obj_ptr;
        mutable obj_ptr_t obj_ptr;
        // For pointers to std::type_info objects
        struct type_t {
          // (get_functor_type_tag, check_functor_type_tag).
-          const boost::core::typeinfo* type;
+          const detail::sp_typeinfo* type;
          // Whether the type is const-qualified.
          bool const_qualified;
@ -80,13 +114,7 @@ namespace boost {
        } type;
        // For function pointers of all kinds
-        typedef void (*func_ptr_t)();
+        mutable void (*func_ptr)();
        mutable func_ptr_t func_ptr;
 #if defined(BOOST_MSVC) && BOOST_MSVC >= 1929
 # pragma warning(push)
 # pragma warning(disable: 5243)
 #endif
        // For bound member pointers
        struct bound_memfunc_ptr_t {
@ -94,10 +122,6 @@ namespace boost {
          void* obj_ptr;
        } bound_memfunc_ptr;
 #if defined(BOOST_MSVC) && BOOST_MSVC >= 1929
 # pragma warning(pop)
 #endif
        // For references to function objects. We explicitly keep
        // track of the cv-qualifiers on the object referenced.
        struct obj_ref_t {
@ -105,15 +129,9 @@ namespace boost {
          bool is_const_qualified;
          bool is_volatile_qualified;
        } obj_ref;
      };
      union BOOST_SYMBOL_VISIBLE function_buffer
      {
        // Type-specific union members
        mutable function_buffer_members members;
        // To relax aliasing constraints
-        mutable char data[sizeof(function_buffer_members)];
+        mutable char data;
      };
      /**
@ -158,15 +176,15 @@ namespace boost {
      template<typename F>
      class get_function_tag
      {
-        typedef typename conditional<(is_pointer<F>::value),
+        typedef typename mpl::if_c<(is_pointer<F>::value),
                                   function_ptr_tag,
                                   function_obj_tag>::type ptr_or_obj_tag;
-        typedef typename conditional<(is_member_pointer<F>::value),
+        typedef typename mpl::if_c<(is_member_pointer<F>::value),
                                   member_ptr_tag,
                                   ptr_or_obj_tag>::type ptr_or_obj_or_mem_tag;
-        typedef typename conditional<(is_reference_wrapper<F>::value),
+        typedef typename mpl::if_c<(is_reference_wrapper<F>::value),
                                   function_obj_ref_tag,
                                   ptr_or_obj_or_mem_tag>::type or_ref_tag;
@ -180,42 +198,45 @@ namespace boost {
      struct reference_manager
      {
        static inline void
-        manage(const function_buffer& in_buffer, function_buffer& out_buffer,
+        manage(const function_buffer& in_buffer, function_buffer& out_buffer, 
               functor_manager_operation_type op)
        {
          switch (op) {
-          case clone_functor_tag:
+          case clone_functor_tag: 
-            out_buffer.members.obj_ref = in_buffer.members.obj_ref;
+            out_buffer.obj_ref = in_buffer.obj_ref;
            return;
          case move_functor_tag:
-            out_buffer.members.obj_ref = in_buffer.members.obj_ref;
+            out_buffer.obj_ref = in_buffer.obj_ref;
-            in_buffer.members.obj_ref.obj_ptr = 0;
+            in_buffer.obj_ref.obj_ptr = 0;
            return;
          case destroy_functor_tag:
-            out_buffer.members.obj_ref.obj_ptr = 0;
+            out_buffer.obj_ref.obj_ptr = 0;
            return;
          case check_functor_type_tag:
            {
              const detail::sp_typeinfo& check_type 
                = *out_buffer.type.type;
              // Check whether we have the same type. We can add
              // cv-qualifiers, but we can't take them away.
-              if (*out_buffer.members.type.type == BOOST_CORE_TYPEID(F)
+              if (BOOST_FUNCTION_COMPARE_TYPE_ID(check_type, BOOST_SP_TYPEID(F))
-                  && (!in_buffer.members.obj_ref.is_const_qualified
+                  && (!in_buffer.obj_ref.is_const_qualified 
-                      || out_buffer.members.type.const_qualified)
+                      || out_buffer.type.const_qualified)
-                  && (!in_buffer.members.obj_ref.is_volatile_qualified
+                  && (!in_buffer.obj_ref.is_volatile_qualified
-                      || out_buffer.members.type.volatile_qualified))
+                      || out_buffer.type.volatile_qualified))
-                out_buffer.members.obj_ptr = in_buffer.members.obj_ref.obj_ptr;
+                out_buffer.obj_ptr = in_buffer.obj_ref.obj_ptr;
              else
-                out_buffer.members.obj_ptr = 0;
+                out_buffer.obj_ptr = 0;
            }
            return;
          case get_functor_type_tag:
-            out_buffer.members.type.type = &BOOST_CORE_TYPEID(F);
+            out_buffer.type.type = &BOOST_SP_TYPEID(F);
-            out_buffer.members.type.const_qualified = in_buffer.members.obj_ref.is_const_qualified;
+            out_buffer.type.const_qualified = in_buffer.obj_ref.is_const_qualified;
-            out_buffer.members.type.volatile_qualified = in_buffer.members.obj_ref.is_volatile_qualified;
+            out_buffer.type.volatile_qualified = in_buffer.obj_ref.is_volatile_qualified;
            return;
          }
        }
@ -229,9 +250,9 @@ namespace boost {
      struct function_allows_small_object_optimization
      {
        BOOST_STATIC_CONSTANT
-          (bool,
+          (bool, 
           value = ((sizeof(F) <= sizeof(function_buffer) &&
-                     (alignment_of<function_buffer>::value
+                     (alignment_of<function_buffer>::value 
                      % alignment_of<F>::value == 0))));
      };
@ -243,7 +264,7 @@ namespace boost {
          A(a)
        {
        }
-
+        
        functor_wrapper(const functor_wrapper& f) :
          F(static_cast<const F&>(f)),
          A(static_cast<const A&>(f))
@ -262,57 +283,61 @@ namespace boost {
        // Function pointers
        static inline void
-        manage_ptr(const function_buffer& in_buffer, function_buffer& out_buffer,
+        manage_ptr(const function_buffer& in_buffer, function_buffer& out_buffer, 
                functor_manager_operation_type op)
        {
          if (op == clone_functor_tag)
-            out_buffer.members.func_ptr = in_buffer.members.func_ptr;
+            out_buffer.func_ptr = in_buffer.func_ptr;
          else if (op == move_functor_tag) {
-            out_buffer.members.func_ptr = in_buffer.members.func_ptr;
+            out_buffer.func_ptr = in_buffer.func_ptr;
-            in_buffer.members.func_ptr = 0;
+            in_buffer.func_ptr = 0;
          } else if (op == destroy_functor_tag)
-            out_buffer.members.func_ptr = 0;
+            out_buffer.func_ptr = 0;
          else if (op == check_functor_type_tag) {
-            if (*out_buffer.members.type.type == BOOST_CORE_TYPEID(Functor))
+            const detail::sp_typeinfo& check_type 
-              out_buffer.members.obj_ptr = &in_buffer.members.func_ptr;
+              = *out_buffer.type.type;
            if (BOOST_FUNCTION_COMPARE_TYPE_ID(check_type, BOOST_SP_TYPEID(Functor)))
              out_buffer.obj_ptr = &in_buffer.func_ptr;
            else
-              out_buffer.members.obj_ptr = 0;
+              out_buffer.obj_ptr = 0;
          } else /* op == get_functor_type_tag */ {
-            out_buffer.members.type.type = &BOOST_CORE_TYPEID(Functor);
+            out_buffer.type.type = &BOOST_SP_TYPEID(Functor);
-            out_buffer.members.type.const_qualified = false;
+            out_buffer.type.const_qualified = false;
-            out_buffer.members.type.volatile_qualified = false;
+            out_buffer.type.volatile_qualified = false;
          }
        }
        // Function objects that fit in the small-object buffer.
        static inline void
-        manage_small(const function_buffer& in_buffer, function_buffer& out_buffer,
+        manage_small(const function_buffer& in_buffer, function_buffer& out_buffer, 
                functor_manager_operation_type op)
        {
          if (op == clone_functor_tag || op == move_functor_tag) {
-            const functor_type* in_functor =
+            const functor_type* in_functor = 
-              reinterpret_cast<const functor_type*>(in_buffer.data);
+              reinterpret_cast<const functor_type*>(&in_buffer.data);
-            new (reinterpret_cast<void*>(out_buffer.data)) functor_type(*in_functor);
+            new (reinterpret_cast<void*>(&out_buffer.data)) functor_type(*in_functor);
            if (op == move_functor_tag) {
-              functor_type* f = reinterpret_cast<functor_type*>(in_buffer.data);
+              functor_type* f = reinterpret_cast<functor_type*>(&in_buffer.data);
              (void)f; // suppress warning about the value of f not being used (MSVC)
              f->~Functor();
            }
          } else if (op == destroy_functor_tag) {
            // Some compilers (Borland, vc6, ...) are unhappy with ~functor_type.
-             functor_type* f = reinterpret_cast<functor_type*>(out_buffer.data);
+             functor_type* f = reinterpret_cast<functor_type*>(&out_buffer.data);
             (void)f; // suppress warning about the value of f not being used (MSVC)
             f->~Functor();
          } else if (op == check_functor_type_tag) {
-             if (*out_buffer.members.type.type == BOOST_CORE_TYPEID(Functor))
+            const detail::sp_typeinfo& check_type 
-              out_buffer.members.obj_ptr = in_buffer.data;
+              = *out_buffer.type.type;
            if (BOOST_FUNCTION_COMPARE_TYPE_ID(check_type, BOOST_SP_TYPEID(Functor)))
              out_buffer.obj_ptr = &in_buffer.data;
            else
-              out_buffer.members.obj_ptr = 0;
+              out_buffer.obj_ptr = 0;
          } else /* op == get_functor_type_tag */ {
-            out_buffer.members.type.type = &BOOST_CORE_TYPEID(Functor);
+            out_buffer.type.type = &BOOST_SP_TYPEID(Functor);
-            out_buffer.members.type.const_qualified = false;
+            out_buffer.type.const_qualified = false;
-            out_buffer.members.type.volatile_qualified = false;
+            out_buffer.type.volatile_qualified = false;            
          }
        }
      };
@ -325,7 +350,7 @@ namespace boost {
        // Function pointers
        static inline void
-        manager(const function_buffer& in_buffer, function_buffer& out_buffer,
+        manager(const function_buffer& in_buffer, function_buffer& out_buffer, 
                functor_manager_operation_type op, function_ptr_tag)
        {
          functor_manager_common<Functor>::manage_ptr(in_buffer,out_buffer,op);
@ -333,16 +358,16 @@ namespace boost {
        // Function objects that fit in the small-object buffer.
        static inline void
-        manager(const function_buffer& in_buffer, function_buffer& out_buffer,
+        manager(const function_buffer& in_buffer, function_buffer& out_buffer, 
-                functor_manager_operation_type op, true_type)
+                functor_manager_operation_type op, mpl::true_)
        {
          functor_manager_common<Functor>::manage_small(in_buffer,out_buffer,op);
        }
-
+        
        // Function objects that require heap allocation
        static inline void
-        manager(const function_buffer& in_buffer, function_buffer& out_buffer,
+        manager(const function_buffer& in_buffer, function_buffer& out_buffer, 
-                functor_manager_operation_type op, false_type)
+                functor_manager_operation_type op, mpl::false_)
        {
          if (op == clone_functor_tag) {
            // Clone the functor
@ -351,27 +376,29 @@ namespace boost {
            // jewillco: Changing this to static_cast because GCC 2.95.3 is
            // obsolete.
            const functor_type* f =
-              static_cast<const functor_type*>(in_buffer.members.obj_ptr);
+              static_cast<const functor_type*>(in_buffer.obj_ptr);
            functor_type* new_f = new functor_type(*f);
-            out_buffer.members.obj_ptr = new_f;
+            out_buffer.obj_ptr = new_f;
          } else if (op == move_functor_tag) {
-            out_buffer.members.obj_ptr = in_buffer.members.obj_ptr;
+            out_buffer.obj_ptr = in_buffer.obj_ptr;
-            in_buffer.members.obj_ptr = 0;
+            in_buffer.obj_ptr = 0;
          } else if (op == destroy_functor_tag) {
            /* Cast from the void pointer to the functor pointer type */
            functor_type* f =
-              static_cast<functor_type*>(out_buffer.members.obj_ptr);
+              static_cast<functor_type*>(out_buffer.obj_ptr);
            delete f;
-            out_buffer.members.obj_ptr = 0;
+            out_buffer.obj_ptr = 0;
          } else if (op == check_functor_type_tag) {
-            if (*out_buffer.members.type.type == BOOST_CORE_TYPEID(Functor))
+            const detail::sp_typeinfo& check_type
-              out_buffer.members.obj_ptr = in_buffer.members.obj_ptr;
+              = *out_buffer.type.type;
            if (BOOST_FUNCTION_COMPARE_TYPE_ID(check_type, BOOST_SP_TYPEID(Functor)))
              out_buffer.obj_ptr = in_buffer.obj_ptr;
            else
-              out_buffer.members.obj_ptr = 0;
+              out_buffer.obj_ptr = 0;
          } else /* op == get_functor_type_tag */ {
-            out_buffer.members.type.type = &BOOST_CORE_TYPEID(Functor);
+            out_buffer.type.type = &BOOST_SP_TYPEID(Functor);
-            out_buffer.members.type.const_qualified = false;
+            out_buffer.type.const_qualified = false;
-            out_buffer.members.type.volatile_qualified = false;
+            out_buffer.type.volatile_qualified = false;
          }
        }
@ -379,35 +406,39 @@ namespace boost {
        // object can use the small-object optimization buffer or
        // whether we need to allocate it on the heap.
        static inline void
-        manager(const function_buffer& in_buffer, function_buffer& out_buffer,
+        manager(const function_buffer& in_buffer, function_buffer& out_buffer, 
                functor_manager_operation_type op, function_obj_tag)
        {
          manager(in_buffer, out_buffer, op,
-                  integral_constant<bool, (function_allows_small_object_optimization<functor_type>::value)>());
+                  mpl::bool_<(function_allows_small_object_optimization<functor_type>::value)>());
        }
        // For member pointers, we use the small-object optimization buffer.
        static inline void
-        manager(const function_buffer& in_buffer, function_buffer& out_buffer,
+        manager(const function_buffer& in_buffer, function_buffer& out_buffer, 
                functor_manager_operation_type op, member_ptr_tag)
        {
-          manager(in_buffer, out_buffer, op, true_type());
+          manager(in_buffer, out_buffer, op, mpl::true_());
        }
      public:
        /* Dispatch to an appropriate manager based on whether we have a
           function pointer or a function object pointer. */
        static inline void
-        manage(const function_buffer& in_buffer, function_buffer& out_buffer,
+        manage(const function_buffer& in_buffer, function_buffer& out_buffer, 
               functor_manager_operation_type op)
        {
          typedef typename get_function_tag<functor_type>::type tag_type;
-          if (op == get_functor_type_tag) {
+          switch (op) {
-            out_buffer.members.type.type = &BOOST_CORE_TYPEID(functor_type);
+          case get_functor_type_tag:
-            out_buffer.members.type.const_qualified = false;
+            out_buffer.type.type = &BOOST_SP_TYPEID(functor_type);
-            out_buffer.members.type.volatile_qualified = false;
+            out_buffer.type.const_qualified = false;
-          } else {
+            out_buffer.type.volatile_qualified = false;
            return;
          default:
            manager(in_buffer, out_buffer, op, tag_type());
            return;
          }
        }
      };
@ -420,7 +451,7 @@ namespace boost {
        // Function pointers
        static inline void
-        manager(const function_buffer& in_buffer, function_buffer& out_buffer,
+        manager(const function_buffer& in_buffer, function_buffer& out_buffer, 
                functor_manager_operation_type op, function_ptr_tag)
        {
          functor_manager_common<Functor>::manage_ptr(in_buffer,out_buffer,op);
@ -428,68 +459,57 @@ namespace boost {
        // Function objects that fit in the small-object buffer.
        static inline void
-        manager(const function_buffer& in_buffer, function_buffer& out_buffer,
+        manager(const function_buffer& in_buffer, function_buffer& out_buffer, 
-                functor_manager_operation_type op, true_type)
+                functor_manager_operation_type op, mpl::true_)
        {
          functor_manager_common<Functor>::manage_small(in_buffer,out_buffer,op);
        }
-
+        
        // Function objects that require heap allocation
        static inline void
-        manager(const function_buffer& in_buffer, function_buffer& out_buffer,
+        manager(const function_buffer& in_buffer, function_buffer& out_buffer, 
-                functor_manager_operation_type op, false_type)
+                functor_manager_operation_type op, mpl::false_)
        {
          typedef functor_wrapper<Functor,Allocator> functor_wrapper_type;
 #if defined(BOOST_NO_CXX11_ALLOCATOR)
          typedef typename Allocator::template rebind<functor_wrapper_type>::other
            wrapper_allocator_type;
          typedef typename wrapper_allocator_type::pointer wrapper_allocator_pointer_type;
 #else
          using wrapper_allocator_type = typename std::allocator_traits<Allocator>::template rebind_alloc<functor_wrapper_type>;
          using wrapper_allocator_pointer_type = typename std::allocator_traits<wrapper_allocator_type>::pointer;
 #endif
          if (op == clone_functor_tag) {
            // Clone the functor
            // GCC 2.95.3 gets the CV qualifiers wrong here, so we
            // can't do the static_cast that we should do.
            const functor_wrapper_type* f =
-              static_cast<const functor_wrapper_type*>(in_buffer.members.obj_ptr);
+              static_cast<const functor_wrapper_type*>(in_buffer.obj_ptr);
            wrapper_allocator_type wrapper_allocator(static_cast<Allocator const &>(*f));
            wrapper_allocator_pointer_type copy = wrapper_allocator.allocate(1);
 #if defined(BOOST_NO_CXX11_ALLOCATOR)
            wrapper_allocator.construct(copy, *f);
 #else
            std::allocator_traits<wrapper_allocator_type>::construct(wrapper_allocator, copy, *f);
 #endif
            // Get back to the original pointer type
            functor_wrapper_type* new_f = static_cast<functor_wrapper_type*>(copy);
-            out_buffer.members.obj_ptr = new_f;
+            out_buffer.obj_ptr = new_f;
          } else if (op == move_functor_tag) {
-            out_buffer.members.obj_ptr = in_buffer.members.obj_ptr;
+            out_buffer.obj_ptr = in_buffer.obj_ptr;
-            in_buffer.members.obj_ptr = 0;
+            in_buffer.obj_ptr = 0;
          } else if (op == destroy_functor_tag) {
            /* Cast from the void pointer to the functor_wrapper_type */
            functor_wrapper_type* victim =
-              static_cast<functor_wrapper_type*>(in_buffer.members.obj_ptr);
+              static_cast<functor_wrapper_type*>(in_buffer.obj_ptr);
            wrapper_allocator_type wrapper_allocator(static_cast<Allocator const &>(*victim));
 #if defined(BOOST_NO_CXX11_ALLOCATOR)
            wrapper_allocator.destroy(victim);
 #else
            std::allocator_traits<wrapper_allocator_type>::destroy(wrapper_allocator, victim);
 #endif
            wrapper_allocator.deallocate(victim,1);
-            out_buffer.members.obj_ptr = 0;
+            out_buffer.obj_ptr = 0;
          } else if (op == check_functor_type_tag) {
-            if (*out_buffer.members.type.type == BOOST_CORE_TYPEID(Functor))
+            const detail::sp_typeinfo& check_type 
-              out_buffer.members.obj_ptr = in_buffer.members.obj_ptr;
+              = *out_buffer.type.type;
            if (BOOST_FUNCTION_COMPARE_TYPE_ID(check_type, BOOST_SP_TYPEID(Functor)))
              out_buffer.obj_ptr = in_buffer.obj_ptr;
            else
-              out_buffer.members.obj_ptr = 0;
+              out_buffer.obj_ptr = 0;
          } else /* op == get_functor_type_tag */ {
-            out_buffer.members.type.type = &BOOST_CORE_TYPEID(Functor);
+            out_buffer.type.type = &BOOST_SP_TYPEID(Functor);
-            out_buffer.members.type.const_qualified = false;
+            out_buffer.type.const_qualified = false;
-            out_buffer.members.type.volatile_qualified = false;
+            out_buffer.type.volatile_qualified = false;
          }
        }
@ -497,27 +517,31 @@ namespace boost {
        // object can use the small-object optimization buffer or
        // whether we need to allocate it on the heap.
        static inline void
-        manager(const function_buffer& in_buffer, function_buffer& out_buffer,
+        manager(const function_buffer& in_buffer, function_buffer& out_buffer, 
                functor_manager_operation_type op, function_obj_tag)
        {
          manager(in_buffer, out_buffer, op,
-                  integral_constant<bool, (function_allows_small_object_optimization<functor_type>::value)>());
+                  mpl::bool_<(function_allows_small_object_optimization<functor_type>::value)>());
        }
      public:
        /* Dispatch to an appropriate manager based on whether we have a
           function pointer or a function object pointer. */
        static inline void
-        manage(const function_buffer& in_buffer, function_buffer& out_buffer,
+        manage(const function_buffer& in_buffer, function_buffer& out_buffer, 
               functor_manager_operation_type op)
        {
          typedef typename get_function_tag<functor_type>::type tag_type;
-          if (op == get_functor_type_tag) {
+          switch (op) {
-            out_buffer.members.type.type = &BOOST_CORE_TYPEID(functor_type);
+          case get_functor_type_tag:
-            out_buffer.members.type.const_qualified = false;
+            out_buffer.type.type = &BOOST_SP_TYPEID(functor_type);
-            out_buffer.members.type.volatile_qualified = false;
+            out_buffer.type.const_qualified = false;
-          } else {
+            out_buffer.type.volatile_qualified = false;
            return;
          default:
            manager(in_buffer, out_buffer, op, tag_type());
            return;
          }
        }
      };
@ -528,24 +552,24 @@ namespace boost {
 #ifdef BOOST_NO_SFINAE
      // These routines perform comparisons between a Boost.Function
      // object and an arbitrary function object (when the last
-      // parameter is false_type) or against zero (when the
+      // parameter is mpl::bool_<false>) or against zero (when the
-      // last parameter is true_type). They are only necessary
+      // last parameter is mpl::bool_<true>). They are only necessary
      // for compilers that don't support SFINAE.
      template<typename Function, typename Functor>
        bool
-        compare_equal(const Function& f, const Functor&, int, true_type)
+        compare_equal(const Function& f, const Functor&, int, mpl::bool_<true>)
        { return f.empty(); }
      template<typename Function, typename Functor>
        bool
        compare_not_equal(const Function& f, const Functor&, int,
-                          true_type)
+                          mpl::bool_<true>)
        { return !f.empty(); }
      template<typename Function, typename Functor>
        bool
        compare_equal(const Function& f, const Functor& g, long,
-                      false_type)
+                      mpl::bool_<false>)
        {
          if (const Functor* fp = f.template target<Functor>())
            return function_equal(*fp, g);
@ -555,7 +579,7 @@ namespace boost {
      template<typename Function, typename Functor>
        bool
        compare_equal(const Function& f, const reference_wrapper<Functor>& g,
-                      int, false_type)
+                      int, mpl::bool_<false>)
        {
          if (const Functor* fp = f.template target<Functor>())
            return fp == g.get_pointer();
@ -565,7 +589,7 @@ namespace boost {
      template<typename Function, typename Functor>
        bool
        compare_not_equal(const Function& f, const Functor& g, long,
-                          false_type)
+                          mpl::bool_<false>)
        {
          if (const Functor* fp = f.template target<Functor>())
            return !function_equal(*fp, g);
@ -576,7 +600,7 @@ namespace boost {
        bool
        compare_not_equal(const Function& f,
                          const reference_wrapper<Functor>& g, int,
-                          false_type)
+                          mpl::bool_<false>)
        {
          if (const Functor* fp = f.template target<Functor>())
            return fp != g.get_pointer();
@ -590,8 +614,8 @@ namespace boost {
       */
      struct vtable_base
      {
-        void (*manager)(const function_buffer& in_buffer,
+        void (*manager)(const function_buffer& in_buffer, 
-                        function_buffer& out_buffer,
+                        function_buffer& out_buffer, 
                        functor_manager_operation_type op);
      };
    } // end namespace function
@ -611,15 +635,15 @@ public:
  /** Determine if the function is empty (i.e., has no target). */
  bool empty() const { return !vtable; }
-  /** Retrieve the type of the stored function object, or type_id<void>()
+  /** Retrieve the type of the stored function object, or BOOST_SP_TYPEID(void)
      if this is empty. */
-  const boost::core::typeinfo& target_type() const
+  const detail::sp_typeinfo& target_type() const
  {
-    if (!vtable) return BOOST_CORE_TYPEID(void);
+    if (!vtable) return BOOST_SP_TYPEID(void);
    detail::function::function_buffer type;
    get_vtable()->manager(functor, type, detail::function::get_functor_type_tag);
-    return *type.members.type.type;
+    return *type.type.type;
  }
  template<typename Functor>
@ -628,35 +652,42 @@ public:
      if (!vtable) return 0;
      detail::function::function_buffer type_result;
-      type_result.members.type.type = &BOOST_CORE_TYPEID(Functor);
+      type_result.type.type = &BOOST_SP_TYPEID(Functor);
-      type_result.members.type.const_qualified = is_const<Functor>::value;
+      type_result.type.const_qualified = is_const<Functor>::value;
-      type_result.members.type.volatile_qualified = is_volatile<Functor>::value;
+      type_result.type.volatile_qualified = is_volatile<Functor>::value;
-      get_vtable()->manager(functor, type_result,
+      get_vtable()->manager(functor, type_result, 
                      detail::function::check_functor_type_tag);
-      return static_cast<Functor*>(type_result.members.obj_ptr);
+      return static_cast<Functor*>(type_result.obj_ptr);
    }
  template<typename Functor>
 #if defined(BOOST_MSVC) && BOOST_WORKAROUND(BOOST_MSVC, < 1300)
    const Functor* target( Functor * = 0 ) const
 #else
    const Functor* target() const
 #endif
    {
      if (!vtable) return 0;
      detail::function::function_buffer type_result;
-      type_result.members.type.type = &BOOST_CORE_TYPEID(Functor);
+      type_result.type.type = &BOOST_SP_TYPEID(Functor);
-      type_result.members.type.const_qualified = true;
+      type_result.type.const_qualified = true;
-      type_result.members.type.volatile_qualified = is_volatile<Functor>::value;
+      type_result.type.volatile_qualified = is_volatile<Functor>::value;
-      get_vtable()->manager(functor, type_result,
+      get_vtable()->manager(functor, type_result, 
                      detail::function::check_functor_type_tag);
      // GCC 2.95.3 gets the CV qualifiers wrong here, so we
      // can't do the static_cast that we should do.
-      return static_cast<const Functor*>(type_result.members.obj_ptr);
+      return static_cast<const Functor*>(type_result.obj_ptr);
    }
  template<typename F>
-    typename boost::enable_if_< !boost::is_function<F>::value, bool >::type
+    bool contains(const F& f) const
 	contains(const F& f) const
    {
 #if defined(BOOST_MSVC) && BOOST_WORKAROUND(BOOST_MSVC, < 1300)
      if (const F* fp = this->target( (F*)0 ))
 #else
      if (const F* fp = this->template target<F>())
 #endif
      {
        return function_equal(*fp, f);
      } else {
@ -664,19 +695,6 @@ public:
      }
    }
  template<typename Fn>
    typename boost::enable_if_< boost::is_function<Fn>::value, bool >::type
 	contains(Fn& f) const
    {
      typedef Fn* F;
      if (const F* fp = this->template target<F>())
      {
        return function_equal(*fp, &f);
      } else {
        return false;
      }
    }
 #if defined(__GNUC__) && __GNUC__ == 3 && __GNUC_MINOR__ <= 3
  // GCC 3.3 and newer cannot copy with the global operator==, due to
  // problems with instantiation of function return types before it
@ -714,22 +732,15 @@ public: // should be protected, but GCC 2.95.3 will fail to allow access
  mutable detail::function::function_buffer functor;
 };
 #if defined(BOOST_CLANG)
 #   pragma clang diagnostic push
 #   pragma clang diagnostic ignored "-Wweak-vtables"
 #endif
 /**
 * The bad_function_call exception class is thrown when a boost::function
 * object is invoked
 */
-class BOOST_SYMBOL_VISIBLE bad_function_call : public std::runtime_error
+class bad_function_call : public std::runtime_error
 {
 public:
  bad_function_call() : std::runtime_error("call to empty boost::function") {}
 };
 #if defined(BOOST_CLANG)
 #   pragma clang diagnostic pop
 #endif
 #ifndef BOOST_NO_SFINAE
 inline bool operator==(const function_base& f,
@ -762,28 +773,28 @@ inline bool operator!=(detail::function::useless_clear_type*,
 template<typename Functor>
  inline bool operator==(const function_base& f, Functor g)
  {
-    typedef integral_constant<bool, (is_integral<Functor>::value)> integral;
+    typedef mpl::bool_<(is_integral<Functor>::value)> integral;
    return detail::function::compare_equal(f, g, 0, integral());
  }
 template<typename Functor>
  inline bool operator==(Functor g, const function_base& f)
  {
-    typedef integral_constant<bool, (is_integral<Functor>::value)> integral;
+    typedef mpl::bool_<(is_integral<Functor>::value)> integral;
    return detail::function::compare_equal(f, g, 0, integral());
  }
 template<typename Functor>
  inline bool operator!=(const function_base& f, Functor g)
  {
-    typedef integral_constant<bool, (is_integral<Functor>::value)> integral;
+    typedef mpl::bool_<(is_integral<Functor>::value)> integral;
    return detail::function::compare_not_equal(f, g, 0, integral());
  }
 template<typename Functor>
  inline bool operator!=(Functor g, const function_base& f)
  {
-    typedef integral_constant<bool, (is_integral<Functor>::value)> integral;
+    typedef mpl::bool_<(is_integral<Functor>::value)> integral;
    return detail::function::compare_not_equal(f, g, 0, integral());
  }
 #else
@ -890,9 +901,10 @@ namespace detail {
 } // end namespace boost
 #undef BOOST_FUNCTION_ENABLE_IF_NOT_INTEGRAL
 #undef BOOST_FUNCTION_COMPARE_TYPE_ID
 #if defined(BOOST_MSVC)
 #   pragma warning( pop )
-#endif
+#endif       
 #endif // BOOST_FUNCTION_BASE_HEADER
--- a/include/boost/function/function_fwd.hpp
+++ b/include/boost/function/function_fwd.hpp
@ -19,7 +19,8 @@ namespace boost { namespace python { namespace objects {
 }}}
 #endif
-#if defined(BOOST_BCB_PARTIAL_SPECIALIZATION_BUG)                         \
+#if defined (BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION)                    \
 || defined(BOOST_BCB_PARTIAL_SPECIALIZATION_BUG)                         \
 || !(defined(BOOST_STRICT_CONFIG) || !defined(__SUNPRO_CC) || __SUNPRO_CC > 0x540)
 #  define BOOST_FUNCTION_NO_FUNCTION_TYPE_SYNTAX
 #endif
--- a/include/boost/function/function_template.hpp
+++ b/include/boost/function/function_template.hpp
@ -11,12 +11,12 @@
 // Note: this header is a header template and must NOT have multiple-inclusion
 // protection.
 #include <boost/function/detail/prologue.hpp>
-#include <boost/core/no_exceptions_support.hpp>
+#include <boost/detail/no_exceptions_support.hpp>
 #if defined(BOOST_MSVC)
 #   pragma warning( push )
 #   pragma warning( disable : 4127 ) // "conditional expression is constant"
-#endif
+#endif       
 #define BOOST_FUNCTION_TEMPLATE_PARMS BOOST_PP_ENUM_PARAMS(BOOST_FUNCTION_NUM_ARGS, typename T)
@ -26,12 +26,7 @@
 #define BOOST_FUNCTION_PARMS BOOST_PP_ENUM(BOOST_FUNCTION_NUM_ARGS,BOOST_FUNCTION_PARM,BOOST_PP_EMPTY)
-#ifdef BOOST_NO_CXX11_RVALUE_REFERENCES
+#define BOOST_FUNCTION_ARGS BOOST_PP_ENUM_PARAMS(BOOST_FUNCTION_NUM_ARGS, a)
 #   define BOOST_FUNCTION_ARGS BOOST_PP_ENUM_PARAMS(BOOST_FUNCTION_NUM_ARGS, a)
 #else
 #   define BOOST_FUNCTION_ARG(J,I,D) static_cast<BOOST_PP_CAT(T,I)&&>(BOOST_PP_CAT(a,I))
 #   define BOOST_FUNCTION_ARGS BOOST_PP_ENUM(BOOST_FUNCTION_NUM_ARGS,BOOST_FUNCTION_ARG,BOOST_PP_EMPTY)
 #endif
 #define BOOST_FUNCTION_ARG_TYPE(J,I,D) \
  typedef BOOST_PP_CAT(T,I) BOOST_PP_CAT(BOOST_PP_CAT(arg, BOOST_PP_INC(I)),_type);
@ -96,7 +91,7 @@ namespace boost {
        static R invoke(function_buffer& function_ptr BOOST_FUNCTION_COMMA
                        BOOST_FUNCTION_PARMS)
        {
-          FunctionPtr f = reinterpret_cast<FunctionPtr>(function_ptr.members.func_ptr);
+          FunctionPtr f = reinterpret_cast<FunctionPtr>(function_ptr.func_ptr);
          return f(BOOST_FUNCTION_ARGS);
        }
      };
@ -113,7 +108,7 @@ namespace boost {
               BOOST_FUNCTION_PARMS)
        {
-          FunctionPtr f = reinterpret_cast<FunctionPtr>(function_ptr.members.func_ptr);
+          FunctionPtr f = reinterpret_cast<FunctionPtr>(function_ptr.func_ptr);
          BOOST_FUNCTION_RETURN(f(BOOST_FUNCTION_ARGS));
        }
      };
@ -131,9 +126,9 @@ namespace boost {
        {
          FunctionObj* f;
          if (function_allows_small_object_optimization<FunctionObj>::value)
-            f = reinterpret_cast<FunctionObj*>(function_obj_ptr.data);
+            f = reinterpret_cast<FunctionObj*>(&function_obj_ptr.data);
          else
-            f = reinterpret_cast<FunctionObj*>(function_obj_ptr.members.obj_ptr);
+            f = reinterpret_cast<FunctionObj*>(function_obj_ptr.obj_ptr);
          return (*f)(BOOST_FUNCTION_ARGS);
        }
      };
@ -152,9 +147,9 @@ namespace boost {
        {
          FunctionObj* f;
          if (function_allows_small_object_optimization<FunctionObj>::value)
-            f = reinterpret_cast<FunctionObj*>(function_obj_ptr.data);
+            f = reinterpret_cast<FunctionObj*>(&function_obj_ptr.data);
          else
-            f = reinterpret_cast<FunctionObj*>(function_obj_ptr.members.obj_ptr);
+            f = reinterpret_cast<FunctionObj*>(function_obj_ptr.obj_ptr);
          BOOST_FUNCTION_RETURN((*f)(BOOST_FUNCTION_ARGS));
        }
      };
@ -170,8 +165,8 @@ namespace boost {
                        BOOST_FUNCTION_PARMS)
        {
-          FunctionObj* f =
+          FunctionObj* f = 
-            reinterpret_cast<FunctionObj*>(function_obj_ptr.members.obj_ptr);
+            reinterpret_cast<FunctionObj*>(function_obj_ptr.obj_ptr);
          return (*f)(BOOST_FUNCTION_ARGS);
        }
      };
@ -188,8 +183,8 @@ namespace boost {
               BOOST_FUNCTION_PARMS)
        {
-          FunctionObj* f =
+          FunctionObj* f = 
-            reinterpret_cast<FunctionObj*>(function_obj_ptr.members.obj_ptr);
+            reinterpret_cast<FunctionObj*>(function_obj_ptr.obj_ptr);
          BOOST_FUNCTION_RETURN((*f)(BOOST_FUNCTION_ARGS));
        }
      };
@ -207,8 +202,8 @@ namespace boost {
                        BOOST_FUNCTION_PARMS)
        {
-          MemberPtr* f =
+          MemberPtr* f = 
-            reinterpret_cast<MemberPtr*>(function_obj_ptr.data);
+            reinterpret_cast<MemberPtr*>(&function_obj_ptr.data);
          return boost::mem_fn(*f)(BOOST_FUNCTION_ARGS);
        }
      };
@ -225,8 +220,8 @@ namespace boost {
               BOOST_FUNCTION_PARMS)
        {
-          MemberPtr* f =
+          MemberPtr* f = 
-            reinterpret_cast<MemberPtr*>(function_obj_ptr.data);
+            reinterpret_cast<MemberPtr*>(&function_obj_ptr.data);
          BOOST_FUNCTION_RETURN(boost::mem_fn(*f)(BOOST_FUNCTION_ARGS));
        }
      };
@ -239,7 +234,7 @@ namespace boost {
      >
      struct BOOST_FUNCTION_GET_FUNCTION_INVOKER
      {
-        typedef typename conditional<(is_void<R>::value),
+        typedef typename mpl::if_c<(is_void<R>::value),
                            BOOST_FUNCTION_VOID_FUNCTION_INVOKER<
                            FunctionPtr,
                            R BOOST_FUNCTION_COMMA
@ -260,7 +255,7 @@ namespace boost {
       >
      struct BOOST_FUNCTION_GET_FUNCTION_OBJ_INVOKER
      {
-        typedef typename conditional<(is_void<R>::value),
+        typedef typename mpl::if_c<(is_void<R>::value),
                            BOOST_FUNCTION_VOID_FUNCTION_OBJ_INVOKER<
                            FunctionObj,
                            R BOOST_FUNCTION_COMMA
@ -281,7 +276,7 @@ namespace boost {
       >
      struct BOOST_FUNCTION_GET_FUNCTION_REF_INVOKER
      {
-        typedef typename conditional<(is_void<R>::value),
+        typedef typename mpl::if_c<(is_void<R>::value),
                            BOOST_FUNCTION_VOID_FUNCTION_REF_INVOKER<
                            FunctionObj,
                            R BOOST_FUNCTION_COMMA
@ -304,7 +299,7 @@ namespace boost {
       >
      struct BOOST_FUNCTION_GET_MEMBER_INVOKER
      {
-        typedef typename conditional<(is_void<R>::value),
+        typedef typename mpl::if_c<(is_void<R>::value),
                            BOOST_FUNCTION_VOID_MEMBER_INVOKER<
                            MemberPtr,
                            R BOOST_FUNCTION_COMMA
@ -321,7 +316,7 @@ namespace boost {
      /* Given the tag returned by get_function_tag, retrieve the
         actual invoker that will be used for the given function
-         object.
+         object. 
         Each specialization contains an "apply" nested class template
         that accepts the function object, return type, function
@ -349,8 +344,9 @@ namespace boost {
          typedef functor_manager<FunctionPtr> manager_type;
        };
-        template<typename FunctionPtr, typename Allocator,
+        template<typename FunctionPtr,
-                 typename R BOOST_FUNCTION_COMMA BOOST_FUNCTION_TEMPLATE_PARMS>
+                 typename R BOOST_FUNCTION_COMMA BOOST_FUNCTION_TEMPLATE_PARMS,
                 typename Allocator>
        struct apply_a
        {
          typedef typename BOOST_FUNCTION_GET_FUNCTION_INVOKER<
@ -383,8 +379,9 @@ namespace boost {
          typedef functor_manager<MemberPtr> manager_type;
        };
-        template<typename MemberPtr, typename Allocator,
+        template<typename MemberPtr,
-                 typename R BOOST_FUNCTION_COMMA BOOST_FUNCTION_TEMPLATE_PARMS>
+                 typename R BOOST_FUNCTION_COMMA BOOST_FUNCTION_TEMPLATE_PARMS,
                 typename Allocator>
        struct apply_a
        {
          typedef typename BOOST_FUNCTION_GET_MEMBER_INVOKER<
@ -417,8 +414,9 @@ namespace boost {
          typedef functor_manager<FunctionObj> manager_type;
        };
-        template<typename FunctionObj, typename Allocator,
+        template<typename FunctionObj,
-                 typename R BOOST_FUNCTION_COMMA BOOST_FUNCTION_TEMPLATE_PARMS>
+                 typename R BOOST_FUNCTION_COMMA BOOST_FUNCTION_TEMPLATE_PARMS,
                 typename Allocator>
        struct apply_a
        {
          typedef typename BOOST_FUNCTION_GET_FUNCTION_OBJ_INVOKER<
@ -450,8 +448,9 @@ namespace boost {
          typedef reference_manager<typename RefWrapper::type> manager_type;
        };
-        template<typename RefWrapper, typename Allocator,
+        template<typename RefWrapper,
-                 typename R BOOST_FUNCTION_COMMA BOOST_FUNCTION_TEMPLATE_PARMS>
+                 typename R BOOST_FUNCTION_COMMA BOOST_FUNCTION_TEMPLATE_PARMS,
                 typename Allocator>
        struct apply_a
        {
          typedef typename BOOST_FUNCTION_GET_FUNCTION_REF_INVOKER<
@ -501,36 +500,28 @@ namespace boost {
        void clear(function_buffer& functor) const
        {
 #if defined(BOOST_GCC) && (__GNUC__ >= 11)
 # pragma GCC diagnostic push
 // False positive in GCC 11/12 for empty function objects
 # pragma GCC diagnostic ignored "-Wmaybe-uninitialized"
 #endif
          if (base.manager)
            base.manager(functor, functor, destroy_functor_tag);
 #if defined(BOOST_GCC) && (__GNUC__ >= 11)
 # pragma GCC diagnostic pop
 #endif
        }
      private:
        // Function pointers
        template<typename FunctionPtr>
-        bool
+        bool 
        assign_to(FunctionPtr f, function_buffer& functor, function_ptr_tag) const
        {
          this->clear(functor);
          if (f) {
            // should be a reinterpret cast, but some compilers insist
            // on giving cv-qualifiers to free functions
-            functor.members.func_ptr = reinterpret_cast<void (*)()>(f);
+            functor.func_ptr = reinterpret_cast<void (*)()>(f);
            return true;
          } else {
            return false;
          }
        }
        template<typename FunctionPtr,typename Allocator>
-        bool
+        bool 
        assign_to_a(FunctionPtr f, function_buffer& functor, Allocator, function_ptr_tag) const
        {
          return assign_to(f,functor,function_ptr_tag());
@ -569,68 +560,59 @@ namespace boost {
        // Function objects
        // Assign to a function object using the small object optimization
        template<typename FunctionObj>
-        void
+        void 
-        assign_functor(FunctionObj f, function_buffer& functor, true_type) const
+        assign_functor(FunctionObj f, function_buffer& functor, mpl::true_) const
        {
-          new (reinterpret_cast<void*>(functor.data)) FunctionObj(f);
+          new (reinterpret_cast<void*>(&functor.data)) FunctionObj(f);
        }
        template<typename FunctionObj,typename Allocator>
-        void
+        void 
-        assign_functor_a(FunctionObj f, function_buffer& functor, Allocator, true_type) const
+        assign_functor_a(FunctionObj f, function_buffer& functor, Allocator, mpl::true_) const
        {
-          assign_functor(f,functor,true_type());
+          assign_functor(f,functor,mpl::true_());
        }
        // Assign to a function object allocated on the heap.
        template<typename FunctionObj>
-        void
+        void 
-        assign_functor(FunctionObj f, function_buffer& functor, false_type) const
+        assign_functor(FunctionObj f, function_buffer& functor, mpl::false_) const
        {
-          functor.members.obj_ptr = new FunctionObj(f);
+          functor.obj_ptr = new FunctionObj(f);
        }
        template<typename FunctionObj,typename Allocator>
-        void
+        void 
-        assign_functor_a(FunctionObj f, function_buffer& functor, Allocator a, false_type) const
+        assign_functor_a(FunctionObj f, function_buffer& functor, Allocator a, mpl::false_) const
        {
          typedef functor_wrapper<FunctionObj,Allocator> functor_wrapper_type;
 #if defined(BOOST_NO_CXX11_ALLOCATOR)
          typedef typename Allocator::template rebind<functor_wrapper_type>::other
            wrapper_allocator_type;
          typedef typename wrapper_allocator_type::pointer wrapper_allocator_pointer_type;
 #else
          using wrapper_allocator_type = typename std::allocator_traits<Allocator>::template rebind_alloc<functor_wrapper_type>;
          using wrapper_allocator_pointer_type = typename std::allocator_traits<wrapper_allocator_type>::pointer;
 #endif
          wrapper_allocator_type wrapper_allocator(a);
          wrapper_allocator_pointer_type copy = wrapper_allocator.allocate(1);
 #if defined(BOOST_NO_CXX11_ALLOCATOR)
          wrapper_allocator.construct(copy, functor_wrapper_type(f,a));
 #else
          std::allocator_traits<wrapper_allocator_type>::construct(wrapper_allocator, copy, functor_wrapper_type(f,a));
 #endif
          functor_wrapper_type* new_f = static_cast<functor_wrapper_type*>(copy);
-          functor.members.obj_ptr = new_f;
+          functor.obj_ptr = new_f;
        }
        template<typename FunctionObj>
-        bool
+        bool 
        assign_to(FunctionObj f, function_buffer& functor, function_obj_tag) const
        {
          if (!boost::detail::function::has_empty_target(boost::addressof(f))) {
-            assign_functor(f, functor,
+            assign_functor(f, functor, 
-                           integral_constant<bool, (function_allows_small_object_optimization<FunctionObj>::value)>());
+                           mpl::bool_<(function_allows_small_object_optimization<FunctionObj>::value)>());
            return true;
          } else {
            return false;
          }
        }
        template<typename FunctionObj,typename Allocator>
-        bool
+        bool 
        assign_to_a(FunctionObj f, function_buffer& functor, Allocator a, function_obj_tag) const
        {
          if (!boost::detail::function::has_empty_target(boost::addressof(f))) {
            assign_functor_a(f, functor, a,
-                           integral_constant<bool, (function_allows_small_object_optimization<FunctionObj>::value)>());
+                           mpl::bool_<(function_allows_small_object_optimization<FunctionObj>::value)>());
            return true;
          } else {
            return false;
@ -639,18 +621,18 @@ namespace boost {
        // Reference to a function object
        template<typename FunctionObj>
-        bool
+        bool 
-        assign_to(const reference_wrapper<FunctionObj>& f,
+        assign_to(const reference_wrapper<FunctionObj>& f, 
                  function_buffer& functor, function_obj_ref_tag) const
        {
-          functor.members.obj_ref.obj_ptr = (void *)(f.get_pointer());
+          functor.obj_ref.obj_ptr = (void *)(f.get_pointer());
-          functor.members.obj_ref.is_const_qualified = is_const<FunctionObj>::value;
+          functor.obj_ref.is_const_qualified = is_const<FunctionObj>::value;
-          functor.members.obj_ref.is_volatile_qualified = is_volatile<FunctionObj>::value;
+          functor.obj_ref.is_volatile_qualified = is_volatile<FunctionObj>::value;
          return true;
        }
        template<typename FunctionObj,typename Allocator>
-        bool
+        bool 
-        assign_to_a(const reference_wrapper<FunctionObj>& f,
+        assign_to_a(const reference_wrapper<FunctionObj>& f, 
                  function_buffer& functor, Allocator, function_obj_ref_tag) const
        {
          return assign_to(f,functor,function_obj_ref_tag());
@ -668,6 +650,17 @@ namespace boost {
    BOOST_FUNCTION_TEMPLATE_PARMS
  >
  class BOOST_FUNCTION_FUNCTION : public function_base
 #if BOOST_FUNCTION_NUM_ARGS == 1
    , public std::unary_function<T0,R>
 #elif BOOST_FUNCTION_NUM_ARGS == 2
    , public std::binary_function<T0,T1,R>
 #endif
  {
  public:
 #ifndef BOOST_NO_VOID_RETURNS
@ -684,7 +677,7 @@ namespace boost {
    vtable_type* get_vtable() const {
      return reinterpret_cast<vtable_type*>(
-               reinterpret_cast<std::size_t>(vtable) & ~static_cast<std::size_t>(0x01));
+               reinterpret_cast<std::size_t>(vtable) & ~static_cast<size_t>(0x01));
    }
    struct clear_type {};
@ -711,15 +704,16 @@ namespace boost {
    typedef BOOST_FUNCTION_FUNCTION self_type;
-    BOOST_DEFAULTED_FUNCTION(BOOST_FUNCTION_FUNCTION(), : function_base() {})
+    BOOST_FUNCTION_FUNCTION() : function_base() { }
    // MSVC chokes if the following two constructors are collapsed into
    // one with a default parameter.
    template<typename Functor>
    BOOST_FUNCTION_FUNCTION(Functor BOOST_FUNCTION_TARGET_FIX(const &) f
 #ifndef BOOST_NO_SFINAE
-                            ,typename boost::enable_if_<
+                            ,typename enable_if_c<
-                             !(is_integral<Functor>::value),
+                            (boost::type_traits::ice_not<
                             (is_integral<Functor>::value)>::value),
                                        int>::type = 0
 #endif // BOOST_NO_SFINAE
                            ) :
@ -730,8 +724,9 @@ namespace boost {
    template<typename Functor,typename Allocator>
    BOOST_FUNCTION_FUNCTION(Functor BOOST_FUNCTION_TARGET_FIX(const &) f, Allocator a
 #ifndef BOOST_NO_SFINAE
-                            ,typename boost::enable_if_<
+                            ,typename enable_if_c<
-                              !(is_integral<Functor>::value),
+                            (boost::type_traits::ice_not<
                             (is_integral<Functor>::value)>::value),
                                        int>::type = 0
 #endif // BOOST_NO_SFINAE
                            ) :
@ -754,13 +749,6 @@ namespace boost {
      this->assign_to_own(f);
    }
 #ifndef BOOST_NO_CXX11_RVALUE_REFERENCES
    BOOST_FUNCTION_FUNCTION(BOOST_FUNCTION_FUNCTION&& f) : function_base()
    {
      this->move_assign(f);
    }
 #endif
    ~BOOST_FUNCTION_FUNCTION() { clear(); }
    result_type operator()(BOOST_FUNCTION_PARMS) const
@ -779,8 +767,9 @@ namespace boost {
    // construct.
    template<typename Functor>
 #ifndef BOOST_NO_SFINAE
-    typename boost::enable_if_<
+    typename enable_if_c<
-                  !(is_integral<Functor>::value),
+               (boost::type_traits::ice_not<
                 (is_integral<Functor>::value)>::value),
               BOOST_FUNCTION_FUNCTION&>::type
 #else
    BOOST_FUNCTION_FUNCTION&
@ -842,25 +831,6 @@ namespace boost {
      return *this;
    }
 #ifndef BOOST_NO_CXX11_RVALUE_REFERENCES
    // Move assignment from another BOOST_FUNCTION_FUNCTION
    BOOST_FUNCTION_FUNCTION& operator=(BOOST_FUNCTION_FUNCTION&& f)
    {
      if (&f == this)
        return *this;
      this->clear();
      BOOST_TRY {
        this->move_assign(f);
      } BOOST_CATCH (...) {
        vtable = 0;
        BOOST_RETHROW;
      }
      BOOST_CATCH_END
      return *this;
    }
 #endif
    void swap(BOOST_FUNCTION_FUNCTION& other)
    {
      if (&other == this)
@ -906,24 +876,9 @@ namespace boost {
    {
      if (!f.empty()) {
        this->vtable = f.vtable;
-        if (this->has_trivial_copy_and_destroy()) {
+        if (this->has_trivial_copy_and_destroy())
-          // Don't operate on storage directly since union type doesn't relax
+          this->functor = f.functor;
-          // strict aliasing rules, despite of having member char type.
+        else
 #         if defined(BOOST_GCC) && (BOOST_GCC >= 40700)
 #           pragma GCC diagnostic push
            // This warning is technically correct, but we don't want to pay the price for initializing
            // just to silence a warning: https://github.com/boostorg/function/issues/27
 #           pragma GCC diagnostic ignored "-Wmaybe-uninitialized"
 #           if (BOOST_GCC >= 110000)
              // GCC 11.3, 12 emit a different warning: https://github.com/boostorg/function/issues/42
 #             pragma GCC diagnostic ignored "-Wuninitialized"
 #           endif
 #         endif
          std::memcpy(this->functor.data, f.functor.data, sizeof(boost::detail::function::function_buffer));
 #         if defined(BOOST_GCC) && (BOOST_GCC >= 40700)
 #           pragma GCC diagnostic pop
 #         endif
        } else
          get_vtable()->base.manager(f.functor, this->functor,
                                     boost::detail::function::clone_functor_tag);
      }
@ -932,15 +887,15 @@ namespace boost {
    template<typename Functor>
    void assign_to(Functor f)
    {
-      using boost::detail::function::vtable_base;
+      using detail::function::vtable_base;
-      typedef typename boost::detail::function::get_function_tag<Functor>::type tag;
+      typedef typename detail::function::get_function_tag<Functor>::type tag;
-      typedef boost::detail::function::BOOST_FUNCTION_GET_INVOKER<tag> get_invoker;
+      typedef detail::function::BOOST_FUNCTION_GET_INVOKER<tag> get_invoker;
      typedef typename get_invoker::
-                         template apply<Functor, R BOOST_FUNCTION_COMMA
+                         template apply<Functor, R BOOST_FUNCTION_COMMA 
                        BOOST_FUNCTION_TEMPLATE_ARGS>
        handler_type;
-
+      
      typedef typename handler_type::invoker_type invoker_type;
      typedef typename handler_type::manager_type manager_type;
@ -948,33 +903,33 @@ namespace boost {
      // static initialization. Otherwise, we will have a race
      // condition here in multi-threaded code. See
      // http://thread.gmane.org/gmane.comp.lib.boost.devel/164902/.
-      static const vtable_type stored_vtable =
+      static const vtable_type stored_vtable = 
        { { &manager_type::manage }, &invoker_type::invoke };
      if (stored_vtable.assign_to(f, functor)) {
        std::size_t value = reinterpret_cast<std::size_t>(&stored_vtable.base);
        // coverity[pointless_expression]: suppress coverity warnings on apparant if(const).
        if (boost::has_trivial_copy_constructor<Functor>::value &&
            boost::has_trivial_destructor<Functor>::value &&
-            boost::detail::function::function_allows_small_object_optimization<Functor>::value)
+            detail::function::function_allows_small_object_optimization<Functor>::value)
-          value |= static_cast<std::size_t>(0x01);
+          value |= static_cast<size_t>(0x01);
-        vtable = reinterpret_cast<boost::detail::function::vtable_base *>(value);
+        vtable = reinterpret_cast<detail::function::vtable_base *>(value);
-      } else
+      } else 
        vtable = 0;
    }
    template<typename Functor,typename Allocator>
    void assign_to_a(Functor f,Allocator a)
    {
-      using boost::detail::function::vtable_base;
+      using detail::function::vtable_base;
-      typedef typename boost::detail::function::get_function_tag<Functor>::type tag;
+      typedef typename detail::function::get_function_tag<Functor>::type tag;
-      typedef boost::detail::function::BOOST_FUNCTION_GET_INVOKER<tag> get_invoker;
+      typedef detail::function::BOOST_FUNCTION_GET_INVOKER<tag> get_invoker;
      typedef typename get_invoker::
-                         template apply_a<Functor, Allocator, R BOOST_FUNCTION_COMMA
+                         template apply_a<Functor, R BOOST_FUNCTION_COMMA 
-                         BOOST_FUNCTION_TEMPLATE_ARGS>
+                         BOOST_FUNCTION_TEMPLATE_ARGS,
                         Allocator>
        handler_type;
-
+      
      typedef typename handler_type::invoker_type invoker_type;
      typedef typename handler_type::manager_type manager_type;
@ -985,57 +940,33 @@ namespace boost {
      static const vtable_type stored_vtable =
        { { &manager_type::manage }, &invoker_type::invoke };
-      if (stored_vtable.assign_to_a(f, functor, a)) {
+      if (stored_vtable.assign_to_a(f, functor, a)) { 
        std::size_t value = reinterpret_cast<std::size_t>(&stored_vtable.base);
        // coverity[pointless_expression]: suppress coverity warnings on apparant if(const).
        if (boost::has_trivial_copy_constructor<Functor>::value &&
            boost::has_trivial_destructor<Functor>::value &&
-            boost::detail::function::function_allows_small_object_optimization<Functor>::value)
+            detail::function::function_allows_small_object_optimization<Functor>::value)
          value |= static_cast<std::size_t>(0x01);
-        vtable = reinterpret_cast<boost::detail::function::vtable_base *>(value);
+        vtable = reinterpret_cast<detail::function::vtable_base *>(value);
-      } else
+      } else 
        vtable = 0;
    }
-    // Moves the value from the specified argument to *this. If the argument
+    // Moves the value from the specified argument to *this. If the argument 
-    // has its function object allocated on the heap, move_assign will pass
+    // has its function object allocated on the heap, move_assign will pass 
-    // its buffer to *this, and set the argument's buffer pointer to NULL.
+    // its buffer to *this, and set the argument's buffer pointer to NULL. 
-    void move_assign(BOOST_FUNCTION_FUNCTION& f)
+    void move_assign(BOOST_FUNCTION_FUNCTION& f) 
-    {
+    { 
      if (&f == this)
        return;
      BOOST_TRY {
        if (!f.empty()) {
          this->vtable = f.vtable;
-          if (this->has_trivial_copy_and_destroy()) {
+          if (this->has_trivial_copy_and_destroy())
-            // Don't operate on storage directly since union type doesn't relax
+            this->functor = f.functor;
-            // strict aliasing rules, despite of having member char type.
+          else
 #           if defined(BOOST_GCC) && (BOOST_GCC >= 40700)
 #             pragma GCC diagnostic push
              // This warning is technically correct, but we don't want to pay the price for initializing
              // just to silence a warning: https://github.com/boostorg/function/issues/27
 #             pragma GCC diagnostic ignored "-Wmaybe-uninitialized"
 #             if (BOOST_GCC >= 120000)
                // GCC 12 emits a different warning: https://github.com/boostorg/function/issues/42
 #               pragma GCC diagnostic ignored "-Wuninitialized"
 #             endif
 #           endif
            std::memcpy(this->functor.data, f.functor.data, sizeof(this->functor.data));
 #           if defined(BOOST_GCC) && (BOOST_GCC >= 40700)
 #             pragma GCC diagnostic pop
 #           endif
          } else
 #if defined(BOOST_GCC) && (__GNUC__ >= 11)
 # pragma GCC diagnostic push
 // False positive in GCC 11/12 for empty function objects (function_n_test.cpp:673)
 # pragma GCC diagnostic ignored "-Wmaybe-uninitialized"
 #endif
            get_vtable()->base.manager(f.functor, this->functor,
                                     boost::detail::function::move_functor_tag);
 #if defined(BOOST_GCC) && (__GNUC__ >= 11)
 # pragma GCC diagnostic pop
 #endif
          f.vtable = 0;
        } else {
          clear();
@ -1082,7 +1013,7 @@ template<typename R BOOST_FUNCTION_COMMA BOOST_FUNCTION_TEMPLATE_PARMS>
 #if BOOST_FUNCTION_NUM_ARGS == 0
 #define BOOST_FUNCTION_PARTIAL_SPEC R (void)
 #else
-#define BOOST_FUNCTION_PARTIAL_SPEC R (BOOST_FUNCTION_TEMPLATE_ARGS)
+#define BOOST_FUNCTION_PARTIAL_SPEC R (BOOST_PP_ENUM_PARAMS(BOOST_FUNCTION_NUM_ARGS,T))
 #endif
 template<typename R BOOST_FUNCTION_COMMA
@ -1097,13 +1028,14 @@ class function<BOOST_FUNCTION_PARTIAL_SPEC>
 public:
-  BOOST_DEFAULTED_FUNCTION(function(), : base_type() {})
+  function() : base_type() {}
  template<typename Functor>
  function(Functor f
 #ifndef BOOST_NO_SFINAE
-           ,typename boost::enable_if_<
+           ,typename enable_if_c<
-                          !(is_integral<Functor>::value),
+                            (boost::type_traits::ice_not<
                          (is_integral<Functor>::value)>::value),
                       int>::type = 0
 #endif
           ) :
@ -1113,8 +1045,9 @@ public:
  template<typename Functor,typename Allocator>
  function(Functor f, Allocator a
 #ifndef BOOST_NO_SFINAE
-           ,typename boost::enable_if_<
+           ,typename enable_if_c<
-                           !(is_integral<Functor>::value),
+                            (boost::type_traits::ice_not<
                          (is_integral<Functor>::value)>::value),
                       int>::type = 0
 #endif
           ) :
@ -1130,30 +1063,17 @@ public:
  function(const base_type& f) : base_type(static_cast<const base_type&>(f)){}
 #ifndef BOOST_NO_CXX11_RVALUE_REFERENCES
  // Move constructors
  function(self_type&& f): base_type(static_cast<base_type&&>(f)){}
  function(base_type&& f): base_type(static_cast<base_type&&>(f)){}
 #endif
  self_type& operator=(const self_type& f)
  {
    self_type(f).swap(*this);
    return *this;
  }
 #ifndef BOOST_NO_CXX11_RVALUE_REFERENCES
  self_type& operator=(self_type&& f)
  {
    self_type(static_cast<self_type&&>(f)).swap(*this);
    return *this;
  }
 #endif
  template<typename Functor>
 #ifndef BOOST_NO_SFINAE
-  typename boost::enable_if_<
+  typename enable_if_c<
-                         !(is_integral<Functor>::value),
+                            (boost::type_traits::ice_not<
                         (is_integral<Functor>::value)>::value),
                      self_type&>::type
 #else
  self_type&
@ -1177,14 +1097,6 @@ public:
    self_type(f).swap(*this);
    return *this;
  }
 #ifndef BOOST_NO_CXX11_RVALUE_REFERENCES
  self_type& operator=(base_type&& f)
  {
    self_type(static_cast<base_type&&>(f)).swap(*this);
    return *this;
  }
 #endif
 };
 #undef BOOST_FUNCTION_PARTIAL_SPEC
@ -1213,9 +1125,6 @@ public:
 #undef BOOST_FUNCTION_TEMPLATE_ARGS
 #undef BOOST_FUNCTION_PARMS
 #undef BOOST_FUNCTION_PARM
 #ifdef BOOST_FUNCTION_ARG
 #   undef BOOST_FUNCTION_ARG
 #endif
 #undef BOOST_FUNCTION_ARGS
 #undef BOOST_FUNCTION_ARG_TYPE
 #undef BOOST_FUNCTION_ARG_TYPES
@ -1224,4 +1133,4 @@ public:
 #if defined(BOOST_MSVC)
 #   pragma warning( pop )
-#endif
+#endif       
--- a/include/boost/function/function_typeof.hpp
+++ b/include/boost/function/function_typeof.hpp
@ -9,7 +9,37 @@
 #ifndef BOOST_FUNCTION_TYPEOF_HPP
 #define BOOST_FUNCTION_TYPEOF_HPP
 #include <boost/function/function_fwd.hpp>
 #include <boost/typeof/typeof.hpp>
-// This header is no longer necessary and is only retained for compatibility
+#include BOOST_TYPEOF_INCREMENT_REGISTRATION_GROUP()
 BOOST_TYPEOF_REGISTER_TYPE(boost::bad_function_call)
 #if !defined(BOOST_FUNCTION_NO_FUNCTION_TYPE_SYNTAX)
 BOOST_TYPEOF_REGISTER_TEMPLATE(boost::function, (typename))
 #endif
 BOOST_TYPEOF_REGISTER_TEMPLATE(boost::function0, (typename))
 BOOST_TYPEOF_REGISTER_TEMPLATE(boost::function1, (typename)(typename))
 BOOST_TYPEOF_REGISTER_TEMPLATE(boost::function2, (typename)(typename)(typename))
 BOOST_TYPEOF_REGISTER_TEMPLATE(boost::function3, 
  (typename)(typename)(typename)(typename))
 BOOST_TYPEOF_REGISTER_TEMPLATE(boost::function4, 
  (typename)(typename)(typename)(typename)(typename))
 BOOST_TYPEOF_REGISTER_TEMPLATE(boost::function5, 
  (typename)(typename)(typename)(typename)(typename)(typename))
 BOOST_TYPEOF_REGISTER_TEMPLATE(boost::function6, 
  (typename)(typename)(typename)(typename)(typename)(typename)(typename))
 BOOST_TYPEOF_REGISTER_TEMPLATE(boost::function7, 
  (typename)(typename)(typename)(typename)(typename)(typename)(typename)
  (typename))
 BOOST_TYPEOF_REGISTER_TEMPLATE(boost::function8, 
  (typename)(typename)(typename)(typename)(typename)(typename)(typename)
  (typename)(typename))
 BOOST_TYPEOF_REGISTER_TEMPLATE(boost::function9, 
  (typename)(typename)(typename)(typename)(typename)(typename)(typename)
  (typename)(typename)(typename))
 BOOST_TYPEOF_REGISTER_TEMPLATE(boost::function10, 
  (typename)(typename)(typename)(typename)(typename)(typename)(typename)
  (typename)(typename)(typename)(typename))
 #endif
--- a/meta/libraries.json
+++ b/meta/libraries.json
@ -1,19 +0,0 @@
 {
    "key": "function",
    "name": "Function",
    "authors": [
        "Doug Gregor"
    ],
    "description": "Function object wrappers for deferred calls or callbacks.",
    "std": [
        "tr1"
    ],
    "category": [
        "Function-objects",
        "Programming"
    ],
    "maintainers": [
        "Peter Dimov <pdimov -at- gmail.com>"
    ],
    "cxxstd": "03"
 }
--- a/test/CMakeLists.txt
+++ b/test/CMakeLists.txt
@ -1,11 +0,0 @@
 # Copyright 2018, 2019 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(BoostTestJamfile OPTIONAL RESULT_VARIABLE HAVE_BOOST_TEST)
 if(HAVE_BOOST_TEST)
 boost_test_jamfile(FILE Jamfile.v2 LINK_LIBRARIES Boost::function Boost::core Boost::lambda)
 endif()
--- a/test/Jamfile.v2
+++ b/test/Jamfile.v2
@ -7,90 +7,61 @@
 # For more information, see http://www.boost.org/
 project
    : requirements <toolset>msvc:<asynch-exceptions>on
    : source-location $(BOOST_ROOT)
    ;
 # bring in rules for testing
 import testing ;
-project
+{
  : default-build
    <warnings>extra
  : requirements
    <toolset>msvc:<warnings-as-errors>on
    <toolset>gcc:<warnings-as-errors>on
    <toolset>clang:<warnings-as-errors>on
  ;
-run function_test.cpp ;
+  test-suite function
-# /usr/include/c++/4.4/bits/shared_ptr.h:146: error: cannot use typeid with -fno-rtti
+    : 
-run function_test.cpp : : : <rtti>off <toolset>gcc-4.4,<cxxstd>0x:<build>no : function_test_no_rtti ;
+  [ run libs/function/test/function_test.cpp :  :  :  : lib_function_test ]
 run function_n_test.cpp ;
 run allocator_test.cpp ;
 run stateless_test.cpp ;
 run lambda_test.cpp ;
 compile-fail function_test_fail1.cpp ;
 compile-fail function_test_fail2.cpp ;
 compile function_30.cpp ;
 compile function_30_repeat.cpp ;
 run function_arith_cxx98.cpp ;
 run function_arith_portable.cpp ;
 run sum_avg_cxx98.cpp ;
 run sum_avg_portable.cpp ;
 run mem_fun_cxx98.cpp ;
 run mem_fun_portable.cpp ;
 run std_bind_cxx98.cpp ;
 run std_bind_portable.cpp ;
 run function_ref_cxx98.cpp ;
 run function_ref_portable.cpp ;
 run contains_test.cpp ;
 run contains2_test.cpp ;
 run nothrow_swap.cpp ;
 run rvalues_test.cpp ;
 compile function_typeof_test.cpp
   : <cxxstd>03:<build>no <cxxstd>98:<build>no <cxxstd>0x:<build>no ;
 run result_arg_types_test.cpp ;
-lib throw_bad_function_call : throw_bad_function_call.cpp : <link>shared:<define>THROW_BAD_FUNCTION_CALL_DYN_LINK=1 ;
+  [ run libs/function/test/function_n_test.cpp :  :  :  :  ]
-run test_bad_function_call.cpp throw_bad_function_call : : : <link>shared : test_bad_function_call_shared ;
+  [ run libs/function/test/allocator_test.cpp ../../../libs/test/build//boost_test_exec_monitor :  :  :  :  ]
 run test_bad_function_call.cpp throw_bad_function_call : : : <link>static : test_bad_function_call_static ;
-lib mixed_cxxstd : mixed_cxxstd.cpp : <link>shared:<define>MIXED_CXXSTD_DYN_LINK=1 ;
+  [ run libs/function/test/stateless_test.cpp ../../../libs/test/build//boost_test_exec_monitor :  :  :  :  ]
-run test_mixed_cxxstd.cpp mixed_cxxstd : : : <link>shared : mixed_cxxstd_shared ;
+  [ run libs/function/test/lambda_test.cpp ../../../libs/test/build//boost_test_exec_monitor :  :  :  :  ]
 run test_mixed_cxxstd.cpp mixed_cxxstd : : : <link>static : mixed_cxxstd_static ;
-run test_mixed_cxxstd.cpp mixed_cxxstd/<cxxstd>98 : : : <link>shared : mixed_cxxstd_shared_98 ;
+  [ compile-fail libs/function/test/function_test_fail1.cpp :  :  :  :  ]
 run test_mixed_cxxstd.cpp mixed_cxxstd/<cxxstd>98 : : : <link>static : mixed_cxxstd_static_98 ;
-run test_mixed_cxxstd.cpp mixed_cxxstd/<cxxstd>0x : : : <link>shared : mixed_cxxstd_shared_0x ;
+  [ compile-fail libs/function/test/function_test_fail2.cpp :  :  :  :  ]
 run test_mixed_cxxstd.cpp mixed_cxxstd/<cxxstd>0x : : : <link>static : mixed_cxxstd_static_0x ;
-local check14 = [ check-target-builds mixed_cxxstd/<cxxstd>14 : : <build>no ] ;
+  [ compile libs/function/test/function_30.cpp :  :  :  :  ] 
-run test_mixed_cxxstd.cpp mixed_cxxstd/<cxxstd>14 : : : <link>shared $(check14) : mixed_cxxstd_shared_14 ;
+  [ run libs/function/test/function_arith_cxx98.cpp :  :  :  :  ]
 run test_mixed_cxxstd.cpp mixed_cxxstd/<cxxstd>14 : : : <link>static $(check14) : mixed_cxxstd_static_14 ;
-lib return_function : return_function.cpp : <link>shared:<define>RETURN_FUNCTION_DYN_LINK=1 ;
+  [ run libs/function/test/function_arith_portable.cpp :  :  :  :  ]
-run test_return_function.cpp return_function : : : <link>shared : return_function_shared ;
+  [ run libs/function/test/sum_avg_cxx98.cpp :  :  :  :  ]
 run test_return_function.cpp return_function : : : <link>static : return_function_static ;
-run test_return_function.cpp return_function/<cxxstd>98 : : : <link>shared : return_function_shared_98 ;
+  [ run libs/function/test/sum_avg_portable.cpp :  :  :  :  ]
 run test_return_function.cpp return_function/<cxxstd>98 : : : <link>static : return_function_static_98 ;
-run test_return_function.cpp return_function/<cxxstd>0x : : : <link>shared : return_function_shared_0x ;
+  [ run libs/function/test/mem_fun_cxx98.cpp :  :  :  :  ]
 run test_return_function.cpp return_function/<cxxstd>0x : : : <link>static : return_function_static_0x ;
-run test_return_function.cpp return_function/<cxxstd>14 : : : <link>shared $(check14) : return_function_shared_14 ;
+  [ run libs/function/test/mem_fun_portable.cpp :  :  :  :  ]
 run test_return_function.cpp return_function/<cxxstd>14 : : : <link>static $(check14) : return_function_static_14 ;
-run quick.cpp ;
+  [ run libs/function/test/std_bind_cxx98.cpp :  :  :  :  ]
-compile issue_42.cpp ;
+  [ run libs/function/test/std_bind_portable.cpp :  :  :  :  ]
-run fn_eq_bind_test.cpp ;
+  [ run libs/function/test/function_ref_cxx98.cpp :  :  :  :  ]
-# /usr/include/c++/4.4/bits/shared_ptr.h:146: error: cannot use typeid with -fno-rtti
+  [ run libs/function/test/function_ref_portable.cpp :  :  :  :  ]
-run contains_test.cpp : : : <rtti>off <toolset>gcc-4.4,<cxxstd>0x:<build>no : contains_test_no_rtti ;
+  
-run contains2_test.cpp : : : <rtti>off <toolset>gcc-4.4,<cxxstd>0x:<build>no : contains2_test_no_rtti ;
+  [ run libs/function/test/contains_test.cpp : : : : ]
  [ run libs/function/test/contains2_test.cpp : : : : ]
  [ run libs/function/test/nothrow_swap.cpp :  :  :  :  ]
-run contains3_test.cpp ;
+  [ compile libs/function/test/function_typeof_test.cpp ]
-run contains3_test.cpp : : : <rtti>off <toolset>gcc-4.4,<cxxstd>0x:<build>no : contains3_test_no_rtti ;
+ ;
 }
--- a/test/allocator_test.cpp
+++ b/test/allocator_test.cpp
@ -7,10 +7,10 @@
 // For more information, see http://www.boost.org
-#include <boost/function.hpp>
+#include <boost/test/minimal.hpp>
 #include <boost/core/lightweight_test.hpp>
 #include <cassert>
 #include <functional>
 #include <boost/function.hpp>
 using namespace std;
 using namespace boost;
@ -74,19 +74,20 @@ struct DoNothing: base
 static void do_nothing() {}
-int main()
+int
 test_main(int, char*[])
 {
  function2<int, int, int> f;
  f.assign( plus_int<disable_small_object_optimization>(), counting_allocator<int>() );
  f.clear();
-  BOOST_TEST_EQ( alloc_count, 1 );
+  BOOST_CHECK(alloc_count == 1);
-  BOOST_TEST_EQ( dealloc_count, 1 );
+  BOOST_CHECK(dealloc_count == 1);
  alloc_count = 0;
  dealloc_count = 0;
  f.assign( plus_int<enable_small_object_optimization>(), counting_allocator<int>() );
  f.clear();
-  BOOST_TEST_EQ( alloc_count, 0 );
+  BOOST_CHECK(alloc_count == 0);
-  BOOST_TEST_EQ( dealloc_count, 0 );
+  BOOST_CHECK(dealloc_count == 0);
  f.assign( plus_int<disable_small_object_optimization>(), std::allocator<int>() );
  f.clear();
  f.assign( plus_int<enable_small_object_optimization>(), std::allocator<int>() );
@ -96,8 +97,8 @@ int main()
  dealloc_count = 0;
  f.assign( &do_minus, counting_allocator<int>() );
  f.clear();
-  BOOST_TEST_EQ( alloc_count, 0 );
+  BOOST_CHECK(alloc_count == 0);
-  BOOST_TEST_EQ( dealloc_count, 0 );
+  BOOST_CHECK(dealloc_count == 0);
  f.assign( &do_minus, std::allocator<int>() );
  f.clear();
@ -106,14 +107,14 @@ int main()
  dealloc_count = 0;
  fv.assign( DoNothing<disable_small_object_optimization>(), counting_allocator<int>() );
  fv.clear();
-  BOOST_TEST_EQ( alloc_count, 1 );
+  BOOST_CHECK(alloc_count == 1);
-  BOOST_TEST_EQ( dealloc_count, 1 );
+  BOOST_CHECK(dealloc_count == 1);
  alloc_count = 0;
  dealloc_count = 0;
  fv.assign( DoNothing<enable_small_object_optimization>(), counting_allocator<int>() );
  fv.clear();
-  BOOST_TEST_EQ( alloc_count, 0 );
+  BOOST_CHECK(alloc_count == 0);
-  BOOST_TEST_EQ( dealloc_count, 0 );
+  BOOST_CHECK(dealloc_count == 0);
  fv.assign( DoNothing<disable_small_object_optimization>(), std::allocator<int>() );
  fv.clear();
  fv.assign( DoNothing<enable_small_object_optimization>(), std::allocator<int>() );
@ -123,8 +124,8 @@ int main()
  dealloc_count = 0;
  fv.assign( &do_nothing, counting_allocator<int>() );
  fv.clear();
-  BOOST_TEST_EQ( alloc_count, 0 );
+  BOOST_CHECK(alloc_count == 0);
-  BOOST_TEST_EQ( dealloc_count, 0 );
+  BOOST_CHECK(dealloc_count == 0);
  fv.assign( &do_nothing, std::allocator<int>() );
  fv.clear();
@ -132,5 +133,5 @@ int main()
  fv.assign(&do_nothing, std::allocator<int>() );
  fv2.assign(fv, std::allocator<int>() );
-  return boost::report_errors();
+  return 0;
 }
--- a/test/cmake_install_test/CMakeLists.txt
+++ b/test/cmake_install_test/CMakeLists.txt
@ -1,17 +0,0 @@
 # Copyright 2018, 2019 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
 cmake_minimum_required(VERSION 3.5...3.16)
 project(cmake_install_test LANGUAGES CXX)
 find_package(boost_function REQUIRED)
 add_executable(main main.cpp)
 target_link_libraries(main Boost::function)
 enable_testing()
 add_test(main main)
 add_custom_target(check COMMAND ${CMAKE_CTEST_COMMAND} --output-on-failure -C $<CONFIG>)
--- a/test/cmake_install_test/main.cpp
+++ b/test/cmake_install_test/main.cpp
@ -1,22 +0,0 @@
 // Copyright 2017, 2021 Peter Dimov.
 // Distributed under the Boost Software License, Version 1.0.
 // https://www.boost.org/LICENSE_1_0.txt
 // See library home page at http://www.boost.org/libs/function
 #include <boost/function.hpp>
 #include <cassert>
 #define BOOST_TEST(expr) assert(expr)
 #define BOOST_TEST_EQ(x1, x2) assert((x1)==(x2))
 int add( int x, int y )
 {
    return x + y;
 }
 int main()
 {
    boost::function<int(int, int)> fn( &add );
    BOOST_TEST_EQ( fn( 1, 2 ), 3 );
 }
--- a/test/cmake_subdir_test/CMakeLists.txt
+++ b/test/cmake_subdir_test/CMakeLists.txt
@ -1,43 +0,0 @@
 # Copyright 2018, 2019 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
 cmake_minimum_required(VERSION 3.5...3.20)
 project(cmake_subdir_test LANGUAGES CXX)
 add_subdirectory(../.. boostorg/function)
 set(deps
 # Primary dependencies
 assert
 bind
 config
 core
 preprocessor
 throw_exception
 type_traits
 typeof
 # Secondary dependencies
 static_assert
 )
 foreach(dep IN LISTS deps)
  add_subdirectory(../../../${dep} boostorg/${dep})
 endforeach()
 # --target check
 add_executable(quick ../quick.cpp)
 target_link_libraries(quick Boost::function Boost::core)
 enable_testing()
 add_test(quick quick)
 add_custom_target(check COMMAND ${CMAKE_CTEST_COMMAND} --output-on-failure -C $<CONFIG>)
--- a/test/contains2_test.cpp
+++ b/test/contains2_test.cpp
@ -9,7 +9,7 @@
 //  http://www.boost.org/LICENSE_1_0.txt)
 #include <boost/function.hpp>
-#include <boost/core/lightweight_test.hpp>
+#include <boost/detail/lightweight_test.hpp>
 static int forty_two()
 {
--- a/test/contains3_test.cpp
+++ b/test/contains3_test.cpp
@ -1,33 +0,0 @@
 // Copyright 2023 Peter Dimov
 // Distributed under the Boost Software License, Version 1.0.
 // https://www.boost.org/LICENSE_1_0.txt
 #include <boost/function.hpp>
 #include <boost/core/lightweight_test.hpp>
 static int f()
 {
    return 1;
 }
 static int g()
 {
    return 2;
 }
 int main()
 {
    {
        boost::function<int()> fn;
        BOOST_TEST( !fn.contains( f ) );
        BOOST_TEST( !fn.contains( g ) );
    }
    {
        boost::function<int()> fn( f );
        BOOST_TEST( fn.contains( f ) );
        BOOST_TEST( !fn.contains( g ) );
    }
    return boost::report_errors();
 }
--- a/test/contains_test.cpp
+++ b/test/contains_test.cpp
@ -5,12 +5,10 @@
 //  1.0. (See accompanying file LICENSE_1_0.txt or copy at
 //  http://www.boost.org/LICENSE_1_0.txt)
 #include <boost/test/minimal.hpp>
 #include <boost/function.hpp>
 #include <boost/core/lightweight_test.hpp>
 #include <boost/ref.hpp>
 #define BOOST_CHECK BOOST_TEST
 static int forty_two() { return 42; }
 struct Seventeen
@ -227,11 +225,11 @@ static void ref_equal_test()
 #endif
 }
-int main()
+int test_main(int, char*[])
 {
  target_test();
  equal_test();
  ref_equal_test();
-  return boost::report_errors();
+  return 0;
 }
--- a/test/fn_eq_bind_test.cpp
+++ b/test/fn_eq_bind_test.cpp
@ -1,87 +0,0 @@
 // Copyright 2023 Peter Dimov
 // Distributed under the Boost Software License, Version 1.0.
 // https://www.boost.org/LICENSE_1_0.txt
 #include <boost/function.hpp>
 #include <boost/bind/bind.hpp>
 #include <boost/core/lightweight_test.hpp>
 using namespace boost::placeholders;
 int f1() { return 1; }
 int f2() { return 2; }
 int main()
 {
    {
        boost::function<int()> fn( boost::bind( f1 ) );
        BOOST_TEST( fn == boost::bind( f1 ) );
        BOOST_TEST( fn != boost::bind( f2 ) );
    }
    {
        boost::function<int(int)> fn( boost::bind( f1 ) );
        BOOST_TEST( fn == boost::bind( f1 ) );
        BOOST_TEST( fn != boost::bind( f2 ) );
    }
    {
        boost::function<int(int, int)> fn( boost::bind( f1 ) );
        BOOST_TEST( fn == boost::bind( f1 ) );
        BOOST_TEST( fn != boost::bind( f2 ) );
    }
    {
        boost::function<int(int, int, int)> fn( boost::bind( f1 ) );
        BOOST_TEST( fn == boost::bind( f1 ) );
        BOOST_TEST( fn != boost::bind( f2 ) );
    }
    {
        boost::function<int(int, int, int, int)> fn( boost::bind( f1 ) );
        BOOST_TEST( fn == boost::bind( f1 ) );
        BOOST_TEST( fn != boost::bind( f2 ) );
    }
    {
        boost::function<int(int, int, int, int, int)> fn( boost::bind( f1 ) );
        BOOST_TEST( fn == boost::bind( f1 ) );
        BOOST_TEST( fn != boost::bind( f2 ) );
    }
    {
        boost::function<int(int, int, int, int, int, int)> fn( boost::bind( f1 ) );
        BOOST_TEST( fn == boost::bind( f1 ) );
        BOOST_TEST( fn != boost::bind( f2 ) );
    }
    {
        boost::function<int(int, int, int, int, int, int, int)> fn( boost::bind( f1 ) );
        BOOST_TEST( fn == boost::bind( f1 ) );
        BOOST_TEST( fn != boost::bind( f2 ) );
    }
    {
        boost::function<int(int, int, int, int, int, int, int, int)> fn( boost::bind( f1 ) );
        BOOST_TEST( fn == boost::bind( f1 ) );
        BOOST_TEST( fn != boost::bind( f2 ) );
    }
    {
        boost::function<int(int, int, int, int, int, int, int, int, int)> fn( boost::bind( f1 ) );
        BOOST_TEST( fn == boost::bind( f1 ) );
        BOOST_TEST( fn != boost::bind( f2 ) );
    }
    return boost::report_errors();
 }
--- a/test/function_30_repeat.cpp
+++ b/test/function_30_repeat.cpp
@ -1,35 +0,0 @@
 // Boost.Function library
 //  Copyright Douglas Gregor 2002-2003. Use, modification and
 //  distribution is subject to 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)
 // For more information, see http://www.boost.org
 // Make sure we don't try to redefine function2
 #include <boost/function/function2.hpp>
 // Define all Boost.Function class templates up to 30 arguments
 #define BOOST_FUNCTION_MAX_ARGS 20
 #include <boost/function.hpp>
 #undef BOOST_FUNCTION_MAX_ARGS
 #define BOOST_FUNCTION_MAX_ARGS 40
 #include <boost/function.hpp>
 #undef BOOST_FUNCTION_MAX_ARGS
 #define BOOST_FUNCTION_MAX_ARGS 25
 #include <boost/function.hpp>
 #undef BOOST_FUNCTION_MAX_ARGS
 #define BOOST_FUNCTION_MAX_ARGS 30
 #include <boost/function.hpp>
 #include <boost/function.hpp>
 int main()
 {
  boost::function0<float> f0;
  boost::function30<float, int, int, int, int, int, int, int, int, int, int,
                    int, int, int, int, int, int, int, int, int, int,
                    int, int, int, int, int, int, int, int, int, int> f30;
  return 0;
 }
--- a/test/function_n_test.cpp
+++ b/test/function_n_test.cpp
@ -7,20 +7,12 @@
 // For more information, see http://www.boost.org
-#if defined(__clang__) && defined(__has_warning)
+#include <boost/test/minimal.hpp>
 # if __has_warning( "-Wself-assign-overloaded" )
 #  pragma clang diagnostic ignored "-Wself-assign-overloaded"
 # endif
 #endif
 #include <boost/function.hpp>
 #include <boost/core/lightweight_test.hpp>
 #include <functional>
 #include <cassert>
 #include <string>
 #define BOOST_CHECK BOOST_TEST
 using namespace boost;
 using std::string;
 using std::negate;
@ -639,7 +631,7 @@ test_ref()
    boost::function2<int, int, int> f(ref(atc));
    BOOST_CHECK(f(1, 3) == 4);
  }
-  catch(std::runtime_error const&) {
+  catch(std::runtime_error e) {
    BOOST_ERROR("Nonthrowing constructor threw an exception");
  }
 }
@ -692,7 +684,7 @@ void test_construct_destroy_count()
   BOOST_CHECK(construction_count == destruction_count);
 }
-int main()
+int test_main(int, char* [])
 {
  test_zero_args();
  test_one_arg();
@ -701,5 +693,5 @@ int main()
  test_member_functions();
  test_ref();
  test_construct_destroy_count();
-  return boost::report_errors();
+  return 0;
 }
--- a/test/function_test.cpp
+++ b/test/function_test.cpp
@ -7,20 +7,12 @@
 // For more information, see http://www.boost.org
-#if defined(__clang__) && defined(__has_warning)
+#include <boost/test/minimal.hpp>
 # if __has_warning( "-Wself-assign-overloaded" )
 #  pragma clang diagnostic ignored "-Wself-assign-overloaded"
 # endif
 #endif
 #include <boost/function.hpp>
 #include <boost/core/lightweight_test.hpp>
 #include <functional>
 #include <string>
 #include <utility>
 #define BOOST_CHECK BOOST_TEST
 using boost::function;
 using std::string;
@ -632,22 +624,11 @@ test_ref()
    boost::function<int (int, int)> f(boost::ref(atc));
    BOOST_CHECK(f(1, 3) == 4);
  }
-  catch(std::runtime_error const&) {
+  catch(std::runtime_error e) {
    BOOST_ERROR("Nonthrowing constructor threw an exception");
  }
 }
 #if BOOST_WORKAROUND(BOOST_GCC, >= 70000 && BOOST_GCC < 80000) && __cplusplus >= 201700
 // https://gcc.gnu.org/bugzilla/show_bug.cgi?id=81311
 #pragma message("Skipping test_empty_ref on g++ 7 -std=c++17")
 static void test_empty_ref()
 {
 }
 #else
 static void dummy() {}
 static void test_empty_ref()
@ -659,20 +640,18 @@ static void test_empty_ref()
    f2();
    BOOST_ERROR("Exception didn't throw for reference to empty function.");
  }
-  catch(std::runtime_error const&) {}
+  catch(std::runtime_error e) {}
  f1 = dummy;
  try {
    f2();
  }
-  catch(std::runtime_error const&) {
+  catch(std::runtime_error e) {
    BOOST_ERROR("Error calling referenced function.");
  }
 }
 #endif
 static void test_exception()
 {
@ -681,7 +660,7 @@ static void test_exception()
    f(5, 4);
    BOOST_CHECK(false);
  }
-  catch(boost::bad_function_call const&) {
+  catch(boost::bad_function_call) {
    // okay
  }
 }
@ -711,96 +690,7 @@ static void test_call()
  test_call_cref(std::plus<int>());
 }
-struct big_aggregating_structure {
+int test_main(int, char* [])
  int disable_small_objects_optimizations[32];
  big_aggregating_structure()
  {
    ++ global_int;
  }
  big_aggregating_structure(const big_aggregating_structure&)
  {
    ++ global_int;
  }
  ~big_aggregating_structure()
  {
    -- global_int;
  }
  void operator()() 
  {
    ++ global_int;
  }
  void operator()(int) 
  {
    ++ global_int;
  }
 };
 template <class FunctionT>
 static void test_move_semantics() 
 {
  typedef FunctionT f1_type;
  big_aggregating_structure obj;
  f1_type f1 = obj;
  global_int = 0;
  f1();
  BOOST_CHECK(!f1.empty());
  BOOST_CHECK(global_int == 1);
 #ifndef BOOST_NO_CXX11_RVALUE_REFERENCES
  // Testing rvalue constructors
  f1_type f2(static_cast<f1_type&&>(f1));
  BOOST_CHECK(f1.empty());
  BOOST_CHECK(!f2.empty());
  BOOST_CHECK(global_int == 1);
  f2();
  BOOST_CHECK(global_int == 2);
  f1_type f3(static_cast<f1_type&&>(f2));
  BOOST_CHECK(f1.empty());
  BOOST_CHECK(f2.empty());
  BOOST_CHECK(!f3.empty());
  BOOST_CHECK(global_int == 2);
  f3();
  BOOST_CHECK(global_int == 3);
  // Testing move assignment
  f1_type f4;
  BOOST_CHECK(f4.empty());
  f4 = static_cast<f1_type&&>(f3);
  BOOST_CHECK(f1.empty());
  BOOST_CHECK(f2.empty());
  BOOST_CHECK(f3.empty());
  BOOST_CHECK(!f4.empty());
  BOOST_CHECK(global_int == 3);
  f4();
  BOOST_CHECK(global_int == 4);
  // Testing self move assignment
  f4 = static_cast<f1_type&&>(f4);
  BOOST_CHECK(!f4.empty());
  BOOST_CHECK(global_int == 4);
  // Testing, that no memory leaked when assigning to nonempty function
  f4 = obj;
  BOOST_CHECK(!f4.empty());
  BOOST_CHECK(global_int == 4);
  f1_type f5 = obj;
  BOOST_CHECK(global_int == 5);
  f4 = static_cast<f1_type&&>(f5);
  BOOST_CHECK(global_int == 4);
 #endif  
 }
 int main()
 {
  test_zero_args();
  test_one_arg();
@ -812,8 +702,6 @@ int main()
  test_exception();
  test_implicit();
  test_call();
  test_move_semantics<function<void()> >();
  test_move_semantics<boost::function0<void> >();
-  return boost::report_errors();
+  return 0;
 }
--- a/test/function_test_fail1.cpp
+++ b/test/function_test_fail1.cpp
@ -7,12 +7,22 @@
 // For more information, see http://www.boost.org
 #include <boost/test/minimal.hpp>
 #include <boost/function.hpp>
-void test()
+using namespace std;
-{
+using namespace boost;
    boost::function0<int> f1;
    boost::function0<int> f2;
-    if( f1 == f2 ) {}
+int
 test_main(int, char*[])
 {
  function0<int> f1;
  function0<int> f2;
  if (f1 == f2) {
  }
  BOOST_ERROR("This should not have compiled.");
  return 0;
 }
--- a/test/function_test_fail2.cpp
+++ b/test/function_test_fail2.cpp
@ -7,12 +7,21 @@
 // For more information, see http://www.boost.org
 #include <boost/test/minimal.hpp>
 #include <boost/function.hpp>
 using namespace std;
 using namespace boost;
 static int bad_fn(float f) { return static_cast<int>(f); }
-void test()
+int
 test_main(int, char*[])
 {
-    boost::function0<int> f1;
+  function0<int> f1;
-    f1 = bad_fn;
+  f1 = bad_fn;
  BOOST_ERROR("This should not have compiled.");
  return 0;
 }
--- a/test/issue_42.cpp
+++ b/test/issue_42.cpp
@ -1,21 +0,0 @@
 // Copyright 2022 Peter Dimov.
 // Distributed under the Boost Software License, Version 1.0.
 // https://www.boost.org/LICENSE_1_0.txt
 //
 // https://github.com/boostorg/function/issues/42
 #include <boost/function.hpp>
 struct F
 {
    int operator()( int x ) const { return -x; }
 };
 struct X
 {
    boost::function<int(int)> f_;
    explicit X( boost::function<int(int)> f ): f_( f ) {}
 };
 F f2;
 X x( f2 ); // -Wuninitialized under GCC 12
--- a/test/lambda_test.cpp
+++ b/test/lambda_test.cpp
@ -7,13 +7,13 @@
 // For more information, see http://www.boost.org
 #include <boost/function.hpp>
 #include <boost/lambda/lambda.hpp>
 #include <boost/lambda/bind.hpp>
 #include <boost/core/lightweight_test.hpp>
 #include <iostream>
 #include <cstdlib>
 #include <boost/test/minimal.hpp>
 #include <boost/lambda/lambda.hpp>
 #include <boost/lambda/bind.hpp>
 #include <boost/function.hpp>
 static unsigned
 func_impl(int arg1, bool arg2, double arg3)
@ -22,19 +22,17 @@ func_impl(int arg1, bool arg2, double arg3)
  return abs (static_cast<int>((arg2 ? arg1 : 2 * arg1) * arg3));
 }
-int main()
+int test_main(int, char*[])
 {
  using boost::function;
  using namespace boost::lambda;
  function <unsigned(bool, double)> f1 = bind(func_impl, 15, _1, _2);
  BOOST_TEST_EQ( f1(true, 2.0), 30u );
  function <unsigned(double)>       f2 = boost::lambda::bind(f1, false, _1);
  BOOST_TEST_EQ( f2(2.0), 60u );
  function <unsigned()>             f3 = boost::lambda::bind(f2, 4.0);
  BOOST_TEST_EQ( f3(), 120u );
-  return boost::report_errors();
+  f3();
  return 0;
 }
--- a/test/mem_fun_cxx98.cpp
+++ b/test/mem_fun_cxx98.cpp
@ -10,36 +10,28 @@
 #include <boost/function.hpp>
-#include <boost/core/lightweight_test.hpp>
+#include <boost/detail/lightweight_test.hpp>
 #include <iostream>
 #include <functional>
 struct Y {
    Y(int y = 0) : y_(y) {}
    bool operator==(const Y& rhs) const { return y_ == rhs.y_; }
 private:
    int y_;
    };
 struct X {
  int foo(int);
-  Y& foo2(Y&) const;
+  std::ostream& foo2(std::ostream&) const;
 };
 int X::foo(int x) { return -x; }
-Y& X::foo2(Y& x) const { return x; }
+std::ostream& X::foo2(std::ostream& x) const { return x; }
 int main()
 {
    boost::function<int (X*, int)> f;
-    boost::function<Y& (X*, Y&)> f2;
+    boost::function<std::ostream& (X*, std::ostream&)> f2;
-	Y y1;
+
    f = &X::foo;
    f2 = &X::foo2;
    X x;
    BOOST_TEST(f(&x, 5) == -5);
-    BOOST_TEST(f2(&x, boost::ref(y1)) == y1);
+    BOOST_TEST(f2(&x, boost::ref(std::cout)) == std::cout);
    return ::boost::report_errors();
 }
--- a/test/mem_fun_portable.cpp
+++ b/test/mem_fun_portable.cpp
@ -10,36 +10,28 @@
 #include <boost/function.hpp>
-#include <boost/core/lightweight_test.hpp>
+#include <boost/detail/lightweight_test.hpp>
 #include <iostream>
 #include <functional>
 struct Y {
    Y(int y = 0) : y_(y) {}
    bool operator==(const Y& rhs) const { return y_ == rhs.y_; }
 private:
    int y_;
    };
 struct X {
  int foo(int);
-  Y& foo2(Y&) const;
+  std::ostream& foo2(std::ostream&) const;
 };
 int X::foo(int x) { return -x; }
-Y& X::foo2(Y& x) const { return x; }
+std::ostream& X::foo2(std::ostream& x) const { return x; }
 int main()
 {
    boost::function2<int, X*, int> f;
-    boost::function2<Y&, X*, Y&> f2;
+    boost::function2<std::ostream&, X*, std::ostream&> f2;
-    Y y1;
+
    f = &X::foo;
    f2 = &X::foo2;
    X x;
    BOOST_TEST(f(&x, 5) == -5);
-    BOOST_TEST(f2(&x, boost::ref(y1)) == y1);
+    BOOST_TEST(f2(&x, boost::ref(std::cout)) == std::cout);
    return ::boost::report_errors();
 }
--- a/test/mixed_cxxstd.cpp
+++ b/test/mixed_cxxstd.cpp
@ -1,42 +0,0 @@
 // Copyright 2018 Peter Dimov.
 // Distributed under the Boost Software License, Version 1.0.
 #include <boost/function.hpp>
 #include <boost/config.hpp>
 #if defined(MIXED_CXXSTD_DYN_LINK)
 # define EXPORT BOOST_SYMBOL_EXPORT
 #else
 # define EXPORT
 #endif
 EXPORT void call_fn_1( boost::function<void()> const & fn )
 {
    fn();
 }
 EXPORT void call_fn_2( boost::function<void(int)> const & fn )
 {
    fn( 1 );
 }
 EXPORT void call_fn_3( boost::function<void(int, int)> const & fn )
 {
    fn( 1, 2 );
 }
 EXPORT void call_fn_4( boost::function0<void> const & fn )
 {
    fn();
 }
 EXPORT void call_fn_5( boost::function1<void, int> const & fn )
 {
    fn( 1 );
 }
 EXPORT void call_fn_6( boost::function2<void, int, int> const & fn )
 {
    fn( 1, 2 );
 }
--- a/test/nothrow_swap.cpp
+++ b/test/nothrow_swap.cpp
@ -7,10 +7,8 @@
 // For more information, see http://www.boost.org
 #include <boost/test/minimal.hpp>
 #include <boost/function.hpp>
 #include <boost/core/lightweight_test.hpp>
 #define BOOST_CHECK BOOST_TEST
 struct tried_to_copy { };
@ -42,7 +40,7 @@ struct MaybeThrowOnCopy {
 bool MaybeThrowOnCopy::throwOnCopy = false;
-int main()
+int test_main(int, char* [])
 {
  boost::function0<int> f;
  boost::function0<int> g;
@ -58,5 +56,5 @@ int main()
  BOOST_CHECK(f() == 2);
  BOOST_CHECK(g() == 1);
-  return boost::report_errors();
+  return 0;
 }
--- a/test/quick.cpp
+++ b/test/quick.cpp
@ -1,21 +0,0 @@
 // Copyright 2019 Peter Dimov
 // Use, modification and distribution is subject to 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/function.hpp>
 #include <boost/core/lightweight_test.hpp>
 static int f( int x )
 {
    return x + 1;
 }
 int main()
 {
    boost::function<int(int)> fn( f );
    BOOST_TEST_EQ( fn( 5 ), 6 );
    return boost::report_errors();
 }
--- a/test/result_arg_types_test.cpp
+++ b/test/result_arg_types_test.cpp
@ -1,39 +0,0 @@
 // Boost.Function library
 //  Copyright 2016 Peter Dimov
 //  Use, modification and distribution is subject to
 //  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/function.hpp>
 #include <boost/core/lightweight_test_trait.hpp>
 struct X
 {
 };
 struct Y
 {
 };
 struct Z
 {
 };
 int main()
 {
    typedef boost::function<X(Y)> F1;
    BOOST_TEST_TRAIT_SAME(F1::result_type, X);
    BOOST_TEST_TRAIT_SAME(F1::argument_type, Y);
    typedef boost::function<X(Y, Z)> F2;
    BOOST_TEST_TRAIT_SAME(F2::result_type, X);
    BOOST_TEST_TRAIT_SAME(F2::first_argument_type, Y);
    BOOST_TEST_TRAIT_SAME(F2::second_argument_type, Z);
    return boost::report_errors();
 }
--- a/test/return_function.cpp
+++ b/test/return_function.cpp
@ -1,27 +0,0 @@
 // Copyright 2018 Peter Dimov.
 // Distributed under the Boost Software License, Version 1.0.
 #include <boost/function.hpp>
 #include <boost/config.hpp>
 #if defined(RETURN_FUNCTION_DYN_LINK)
 # define EXPORT BOOST_SYMBOL_EXPORT
 #else
 # define EXPORT
 #endif
 int f( int x, int y )
 {
    return x + y;
 }
 EXPORT boost::function<int(int, int)> get_fn_1()
 {
    return f;
 }
 EXPORT boost::function2<int, int, int> get_fn_2()
 {
    return f;
 }
--- a/test/rvalues_test.cpp
+++ b/test/rvalues_test.cpp
@ -1,107 +0,0 @@
 // Copyright 2014 Antony Polukhin.
 //
 // 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)
 // For more information, see http://www.boost.org
 #include <boost/function.hpp>
 #include <boost/move/move.hpp>
 #include <boost/core/lightweight_test.hpp>
 #include <iostream>
 #include <cstdlib>
 #define BOOST_CHECK BOOST_TEST
 class only_movable {
 private:
    BOOST_MOVABLE_BUT_NOT_COPYABLE(only_movable)
    int value_;
    bool moved_;
 public:
    only_movable(BOOST_RV_REF(only_movable) x)
        : value_(x.value_)
        , moved_(false)
    {
        x.moved_ = true;
    }
   only_movable& operator=(BOOST_RV_REF(only_movable) x) {
        value_ = x.value_;
        x.moved_ = true;
        moved_ = false;
        return *this;
   }
    explicit only_movable(int value = 0) : value_(value), moved_(false) {}
    int get_value() const {  return value_;  }
    bool is_moved() const { return moved_; }
 };
 int one(BOOST_RV_REF(only_movable) v) { return v.get_value(); }
 only_movable two(BOOST_RV_REF(only_movable) t) {
    only_movable t1 = boost::move(t);
    return BOOST_MOVE_RET(only_movable, t1);
 }
 only_movable two_sum(BOOST_RV_REF(only_movable) t1, BOOST_RV_REF(only_movable) t2) {
    only_movable ret(t1.get_value() + t2.get_value());
    return BOOST_MOVE_RET(only_movable, ret);
 }
 struct sum_struct {
    only_movable operator()(BOOST_RV_REF(only_movable) t1, BOOST_RV_REF(only_movable) t2) const {
        only_movable ret(t1.get_value() + t2.get_value());
        return BOOST_MOVE_RET(only_movable, ret);
    }
 };
 #ifndef BOOST_NO_CXX11_RVALUE_REFERENCES
 int three(std::string&&) { return 1; }
 std::string&& four(std::string&& s) { return boost::move(s); }
 #endif
 int main()
 {
    using boost::function;
    function <int(BOOST_RV_REF(only_movable))>  f1 = one;
    only_movable om1(1);
    BOOST_CHECK(f1(boost::move(om1)) == 1);
    function <only_movable(BOOST_RV_REF(only_movable))>  f2 = two;
    only_movable om2(2);
    only_movable om2_2 = f2(boost::move(om2));
    BOOST_CHECK(om2_2.get_value() == 2);
    BOOST_CHECK(om2.is_moved());
    {
        function <only_movable(BOOST_RV_REF(only_movable), BOOST_RV_REF(only_movable))>  f2_sum = two_sum;
        only_movable om1_sum(1), om2_sum(2);
        only_movable om2_sum_2 = f2_sum(boost::move(om1_sum), boost::move(om2_sum));
        BOOST_CHECK(om2_sum_2.get_value() == 3);
    }
    {
        sum_struct s;
        function <only_movable(BOOST_RV_REF(only_movable), BOOST_RV_REF(only_movable))>  f2_sum = s;
        only_movable om1_sum(1), om2_sum(2);
        only_movable om2_sum_2 = f2_sum(boost::move(om1_sum), boost::move(om2_sum));
        BOOST_CHECK(om2_sum_2.get_value() == 3);
    }
 #ifndef BOOST_NO_CXX11_RVALUE_REFERENCES
    function <int(std::string&&)>               f3 = three;
    function <std::string&& (std::string&& s)>  f4 = four;
    f3(std::string("Hello"));
    BOOST_CHECK(f4(std::string("world")) == "world");
 #endif
    return boost::report_errors();
 }
--- a/test/stateless_test.cpp
+++ b/test/stateless_test.cpp
@ -7,18 +7,16 @@
 // For more information, see http://www.boost.org
 #include <boost/test/minimal.hpp>
 #include <boost/function.hpp>
 #include <boost/core/lightweight_test.hpp>
 #include <stdexcept>
 #include <new>
 struct stateless_integer_add {
  int operator()(int x, int y) const { return x+y; }
-  void* operator new(std::size_t n)
+  void* operator new(std::size_t)
  {
-    BOOST_ERROR( "stateless_integer_add incorrectly allocated" );
+    throw std::runtime_error("Cannot allocate a stateless_integer_add");
    return ::operator new( n );
  }
  void* operator new(std::size_t, void* p)
@ -26,17 +24,15 @@ struct stateless_integer_add {
    return p;
  }
-  void operator delete(void* p) throw()
+  void operator delete(void*) throw()
  {
    BOOST_ERROR( "stateless_integer_add incorrectly deallocated" );
    return ::operator delete( p );
  }
 };
-int main()
+int test_main(int, char*[])
 {
  boost::function2<int, int, int> f;
  f = stateless_integer_add();
-  return boost::report_errors();
+  return 0;
 }
--- a/test/std_bind_cxx98.cpp
+++ b/test/std_bind_cxx98.cpp
@ -8,16 +8,7 @@
 // For more information, see http://www.boost.org/
-#if defined(__clang__) && defined(__has_warning)
+    
 # if __has_warning( "-Wdeprecated-declarations" )
 #  pragma clang diagnostic ignored "-Wdeprecated-declarations"
 # endif
 #endif
 #if defined(__GNUC__) && __GNUC__ >= 12
 # pragma GCC diagnostic ignored "-Wdeprecated-declarations"
 #endif
 #include <boost/function.hpp>
 #include <iostream>
 #include <functional>
@ -29,12 +20,11 @@ int X::foo(int x) { return -x; }
 int main()
 {
 #ifndef BOOST_NO_CXX98_BINDERS
      boost::function<int (int)> f;
  X x;
  f = std::bind1st(
        std::mem_fun(&X::foo), &x);
  f(5); // Call x.foo(5)
-#endif
+
    return 0;
 }
--- a/test/std_bind_portable.cpp
+++ b/test/std_bind_portable.cpp
@ -8,16 +8,7 @@
 // For more information, see http://www.boost.org/
-#if defined(__clang__) && defined(__has_warning)
+    
 # if __has_warning( "-Wdeprecated-declarations" )
 #  pragma clang diagnostic ignored "-Wdeprecated-declarations"
 # endif
 #endif
 #if defined(__GNUC__) && __GNUC__ >= 12
 # pragma GCC diagnostic ignored "-Wdeprecated-declarations"
 #endif
 #include <boost/function.hpp>
 #include <iostream>
 #include <functional>
@ -29,12 +20,11 @@ int X::foo(int x) { return -x; }
 int main()
 {
 #ifndef BOOST_NO_CXX98_BINDERS
      boost::function1<int, int> f;
  X x;
  f = std::bind1st(
        std::mem_fun(&X::foo), &x);
  f(5); // Call x.foo(5)
-#endif
+
    return 0;
 }
--- a/test/test_bad_function_call.cpp
+++ b/test/test_bad_function_call.cpp
@ -1,14 +0,0 @@
 // Copyright 2018 Peter Dimov.
 // Distributed under the Boost Software License, Version 1.0.
 #include <boost/function.hpp>
 #include <boost/core/lightweight_test.hpp>
 void throw_bad_function_call();
 int main()
 {
    BOOST_TEST_THROWS( throw_bad_function_call(), boost::bad_function_call );
    return boost::report_errors();
 }
--- a/test/test_mixed_cxxstd.cpp
+++ b/test/test_mixed_cxxstd.cpp
@ -1,48 +0,0 @@
 // Copyright 2018 Peter Dimov.
 // Distributed under the Boost Software License, Version 1.0.
 #include <boost/function.hpp>
 #include <boost/core/lightweight_test.hpp>
 //
 void call_fn_1( boost::function<void()> const & fn );
 void call_fn_2( boost::function<void(int)> const & fn );
 void call_fn_3( boost::function<void(int, int)> const & fn );
 void call_fn_4( boost::function0<void> const & fn );
 void call_fn_5( boost::function1<void, int> const & fn );
 void call_fn_6( boost::function2<void, int, int> const & fn );
 //
 static int v;
 void f0()
 {
    v = -1;
 }
 void f1( int x )
 {
    v = x;
 }
 void f2( int x, int y )
 {
    v = x + y;
 }
 int main()
 {
    v = 0; call_fn_1( f0 ); BOOST_TEST_EQ( v, -1 );
    v = 0; call_fn_2( f1 ); BOOST_TEST_EQ( v, 1 );
    v = 0; call_fn_3( f2 ); BOOST_TEST_EQ( v, 3 );
    v = 0; call_fn_4( f0 ); BOOST_TEST_EQ( v, -1 );
    v = 0; call_fn_5( f1 ); BOOST_TEST_EQ( v, 1 );
    v = 0; call_fn_6( f2 ); BOOST_TEST_EQ( v, 3 );
    return boost::report_errors();
 }
--- a/test/test_return_function.cpp
+++ b/test/test_return_function.cpp
@ -1,21 +0,0 @@
 // Copyright 2018 Peter Dimov.
 // Distributed under the Boost Software License, Version 1.0.
 #include <boost/function.hpp>
 #include <boost/core/lightweight_test.hpp>
 //
 boost::function<int(int, int)> get_fn_1();
 boost::function2<int, int, int> get_fn_2();
 //
 int main()
 {
    BOOST_TEST_EQ( get_fn_1()( 1, 2 ), 3 );
    BOOST_TEST_EQ( get_fn_2()( 1, 2 ), 3 );
    return boost::report_errors();
 }
--- a/test/throw_bad_function_call.cpp
+++ b/test/throw_bad_function_call.cpp
@ -1,17 +0,0 @@
 // Copyright 2018 Peter Dimov.
 // Distributed under the Boost Software License, Version 1.0.
 #include <boost/function.hpp>
 #include <boost/config.hpp>
 #if defined(THROW_BAD_FUNCTION_CALL_DYN_LINK)
 # define EXPORT BOOST_SYMBOL_EXPORT
 #else
 # define EXPORT
 #endif
 EXPORT void throw_bad_function_call()
 {
    throw boost::bad_function_call();
 }