aboutsummaryrefslogtreecommitdiffstats
path: root/contrib/libs/cxxsupp/libcxx/include/module.modulemap
blob: ae1d2aeba980894d60b1c3da392d3addc0fc6dd0 (plain) (blame)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
516
517
518
519
520
521
522
523
524
525
526
527
528
529
530
531
532
533
534
535
536
537
538
539
540
541
542
543
544
545
546
547
548
549
550
551
552
553
554
555
556
557
558
559
560
561
562
563
564
565
566
567
568
569
570
571
572
573
574
575
576
577
578
579
580
581
582
583
584
585
586
587
588
589
590
591
592
593
594
595
596
597
598
599
600
601
602
603
604
605
606
607
608
609
610
611
612
613
614
615
616
617
618
619
620
621
622
623
624
625
626
627
628
629
630
631
632
633
634
635
636
637
638
639
640
641
642
643
644
645
646
647
648
649
650
651
652
653
654
655
656
657
658
659
660
661
662
663
664
665
666
667
668
669
670
671
672
673
674
675
676
677
678
679
680
681
682
683
684
685
686
687
688
689
690
691
692
693
694
695
696
697
698
699
700
701
702
703
704
705
706
707
708
709
710
711
712
713
714
715
716
717
718
719
720
721
722
723
724
725
726
727
728
729
730
731
732
733
734
735
736
737
738
739
740
741
742
743
744
745
746
747
748
749
750
751
752
753
754
755
756
757
758
759
760
761
762
763
764
765
766
767
768
769
770
771
772
773
774
775
776
777
778
779
780
781
782
783
784
785
786
787
788
789
790
791
792
793
794
795
796
797
798
799
800
801
802
803
804
805
806
807
808
809
810
811
812
813
814
815
816
817
818
819
820
821
822
823
824
825
826
827
828
829
830
831
832
833
834
835
836
837
838
839
840
841
842
843
844
845
846
847
848
849
850
851
852
853
854
855
856
857
858
859
860
861
862
863
864
865
866
867
868
869
870
871
872
873
874
875
876
877
878
879
880
881
882
883
884
885
886
887
888
889
890
891
892
893
894
895
896
897
898
899
900
901
902
903
904
905
906
907
908
909
910
911
912
913
914
915
916
917
918
919
920
921
922
923
924
925
926
927
928
929
930
931
932
933
934
935
936
937
938
939
940
941
942
943
944
945
946
947
948
949
950
951
952
953
954
955
956
957
958
959
960
961
962
963
964
965
966
967
968
969
970
971
972
973
974
975
976
977
978
979
980
981
982
983
984
985
986
987
988
989
990
991
992
993
994
995
996
997
998
999
1000
1001
1002
1003
1004
1005
1006
1007
1008
1009
1010
1011
1012
1013
1014
1015
1016
1017
1018
1019
1020
1021
1022
1023
1024
1025
1026
1027
1028
1029
1030
1031
1032
1033
1034
1035
1036
1037
1038
1039
1040
1041
1042
1043
1044
1045
1046
1047
1048
1049
1050
1051
1052
// define the module for __config outside of the top level 'std' module
// since __config may be included from C headers which may create an
// include cycle.
module std_config [system] [extern_c] {
    header "__config"
}

module std [system] {
  export std_config
  // FIXME: The standard does not require that each of these submodules
  // re-exports its imported modules. We should provide an alternative form of
  // export that issues a warning if a name from the submodule is used, and
  // use that to provide a 'strict mode' for libc++.

  // Deprecated C-compatibility headers. These can all be included from within
  // an 'extern "C"' context.
  module depr [extern_c] {
    // <assert.h> provided by C library.
    module ctype_h {
      header "ctype.h"
      export *
    }
    module errno_h {
      header "errno.h"
      export *
    }
    module fenv_h {
      header "fenv.h"
      export *
    }
    // <float.h> provided by compiler or C library.
    module inttypes_h {
      header "inttypes.h"
      export stdint_h
      export *
    }
    // <iso646.h> provided by compiler.
    // <limits.h> provided by compiler or C library.
    module locale_h {
      header "locale.h"
      export *
    }
    module math_h {
      header "math.h"
      export *
    }
    module setjmp_h {
      header "setjmp.h"
      export *
    }
    // FIXME: <stdalign.h> is missing.
    // <signal.h> provided by C library.
    // <stdarg.h> provided by compiler.
    // <stdbool.h> provided by compiler.
    module stddef_h {
      // <stddef.h>'s __need_* macros require textual inclusion.
      textual header "stddef.h"
    }
    module stdint_h {
      header "stdint.h"
      export *
      // FIXME: This module only exists on OS X and for some reason the
      // wildcard above doesn't export it.
      export Darwin.C.stdint
    }
    module stdio_h {
      // <stdio.h>'s __need_* macros require textual inclusion.
      textual header "stdio.h"
      export *
      export Darwin.C.stdio
    }
    module stdlib_h {
      // <stdlib.h>'s __need_* macros require textual inclusion.
      textual header "stdlib.h"
      export *
    }
    module string_h {
      header "string.h"
      export *
    }
    // FIXME: <uchar.h> is missing.
    // <time.h> provided by C library.
    module wchar_h {
      // <wchar.h>'s __need_* macros require textual inclusion.
      textual header "wchar.h"
      export *
    }
    module wctype_h {
      header "wctype.h"
      export *
    }
  }

  // <complex.h> and <tgmath.h> are not C headers in any real sense, do not
  // allow their use in extern "C" contexts.
  module complex_h {
    header "complex.h"
    export ccomplex
    export *
  }
  module tgmath_h {
    header "tgmath.h"
    export ccomplex
    export cmath
    export *
  }

  // C compatibility headers.
  module compat {
    module cassert {
      // <cassert>'s use of NDEBUG requires textual inclusion.
      textual header "cassert"
    }
    module ccomplex {
      header "ccomplex"
      export complex
      export *
    }
    module cctype {
      header "cctype"
      export *
    }
    module cerrno {
      header "cerrno"
      export *
    }
    module cfenv {
      header "cfenv"
      export *
    }
    module cfloat {
      header "cfloat"
      export *
    }
    module cinttypes {
      header "cinttypes"
      export cstdint
      export *
    }
    module ciso646 {
      header "ciso646"
      export *
    }
    module climits {
      header "climits"
      export *
    }
    module clocale {
      header "clocale"
      export *
    }
    module cmath {
      header "cmath"
      export *
    }
    module csetjmp {
      header "csetjmp"
      export *
    }
    module csignal {
      header "csignal"
      export *
    }
    // FIXME: <cstdalign> is missing.
    module cstdarg {
      header "cstdarg"
      export *
    }
    module cstdbool {
      header "cstdbool"
      export *
    }
    module cstddef {
      header "cstddef"
      export *
    }
    module cstdint {
      header "cstdint"
      export depr.stdint_h
      export *
    }
    module cstdio {
      header "cstdio"
      export *
    }
    module cstdlib {
      header "cstdlib"
      export *
    }
    module cstring {
      header "cstring"
      export *
    }
    module ctgmath {
      header "ctgmath"
      export ccomplex
      export cmath
      export *
    }
    module ctime {
      header "ctime"
      export *
    }
    // FIXME: <cuchar> is missing.
    module cwchar {
      header "cwchar"
      export depr.stdio_h
      export *
    }
    module cwctype {
      header "cwctype"
      export *
    }
  }

  module algorithm {
    header "algorithm"
    export initializer_list
    export *

    module __algorithm {
      module adjacent_find            { private header "__algorithm/adjacent_find.h" }
      module all_of                   { private header "__algorithm/all_of.h" }
      module any_of                   { private header "__algorithm/any_of.h" }
      module binary_search            { private header "__algorithm/binary_search.h" }
      module clamp                    { private header "__algorithm/clamp.h" }
      module comp                     { private header "__algorithm/comp.h" }
      module comp_ref_type            { private header "__algorithm/comp_ref_type.h" }
      module copy                     { private header "__algorithm/copy.h" }
      module copy_backward            { private header "__algorithm/copy_backward.h" }
      module copy_if                  { private header "__algorithm/copy_if.h" }
      module copy_n                   { private header "__algorithm/copy_n.h" }
      module count                    { private header "__algorithm/count.h" }
      module count_if                 { private header "__algorithm/count_if.h" }
      module equal                    { private header "__algorithm/equal.h" }
      module equal_range              { private header "__algorithm/equal_range.h" }
      module fill                     { private header "__algorithm/fill.h" }
      module fill_n                   { private header "__algorithm/fill_n.h" }
      module find                     { private header "__algorithm/find.h" }
      module find_end                 { private header "__algorithm/find_end.h" }
      module find_first_of            { private header "__algorithm/find_first_of.h" }
      module find_if                  { private header "__algorithm/find_if.h" }
      module find_if_not              { private header "__algorithm/find_if_not.h" }
      module for_each                 { private header "__algorithm/for_each.h" }
      module for_each_n               { private header "__algorithm/for_each_n.h" }
      module generate                 { private header "__algorithm/generate.h" }
      module generate_n               { private header "__algorithm/generate_n.h" }
      module half_positive            { private header "__algorithm/half_positive.h" }
      module includes                 { private header "__algorithm/includes.h" }
      module inplace_merge            { private header "__algorithm/inplace_merge.h" }
      module is_heap                  { private header "__algorithm/is_heap.h" }
      module is_heap_until            { private header "__algorithm/is_heap_until.h" }
      module is_partitioned           { private header "__algorithm/is_partitioned.h" }
      module is_permutation           { private header "__algorithm/is_permutation.h" }
      module is_sorted                { private header "__algorithm/is_sorted.h" }
      module is_sorted_until          { private header "__algorithm/is_sorted_until.h" }
      module iter_swap                { private header "__algorithm/iter_swap.h" }
      module lexicographical_compare  { private header "__algorithm/lexicographical_compare.h" }
      module lower_bound              { private header "__algorithm/lower_bound.h" }
      module make_heap                { private header "__algorithm/make_heap.h" }
      module max                      { private header "__algorithm/max.h" }
      module max_element              { private header "__algorithm/max_element.h" }
      module merge                    { private header "__algorithm/merge.h" }
      module min                      { private header "__algorithm/min.h" }
      module min_element              { private header "__algorithm/min_element.h" }
      module minmax                   { private header "__algorithm/minmax.h" }
      module minmax_element           { private header "__algorithm/minmax_element.h" }
      module mismatch                 { private header "__algorithm/mismatch.h" }
      module move                     { private header "__algorithm/move.h" }
      module move_backward            { private header "__algorithm/move_backward.h" }
      module next_permutation         { private header "__algorithm/next_permutation.h" }
      module none_of                  { private header "__algorithm/none_of.h" }
      module nth_element              { private header "__algorithm/nth_element.h" }
      module partial_sort             { private header "__algorithm/partial_sort.h" }
      module partial_sort_copy        { private header "__algorithm/partial_sort_copy.h" }
      module partition                { private header "__algorithm/partition.h" }
      module partition_copy           { private header "__algorithm/partition_copy.h" }
      module partition_point          { private header "__algorithm/partition_point.h" }
      module pop_heap                 { private header "__algorithm/pop_heap.h" }
      module prev_permutation         { private header "__algorithm/prev_permutation.h" }
      module push_heap                { private header "__algorithm/push_heap.h" }
      module remove                   { private header "__algorithm/remove.h" }
      module remove_copy              { private header "__algorithm/remove_copy.h" }
      module remove_copy_if           { private header "__algorithm/remove_copy_if.h" }
      module remove_if                { private header "__algorithm/remove_if.h" }
      module replace                  { private header "__algorithm/replace.h" }
      module replace_copy             { private header "__algorithm/replace_copy.h" }
      module replace_copy_if          { private header "__algorithm/replace_copy_if.h" }
      module replace_if               { private header "__algorithm/replace_if.h" }
      module reverse                  { private header "__algorithm/reverse.h" }
      module reverse_copy             { private header "__algorithm/reverse_copy.h" }
      module rotate                   { private header "__algorithm/rotate.h" }
      module rotate_copy              { private header "__algorithm/rotate_copy.h" }
      module sample                   { private header "__algorithm/sample.h" }
      module search                   { private header "__algorithm/search.h" }
      module search_n                 { private header "__algorithm/search_n.h" }
      module set_difference           { private header "__algorithm/set_difference.h" }
      module set_intersection         { private header "__algorithm/set_intersection.h" }
      module set_symmetric_difference { private header "__algorithm/set_symmetric_difference.h" }
      module set_union                { private header "__algorithm/set_union.h" }
      module shift_left               { private header "__algorithm/shift_left.h" }
      module shift_right              { private header "__algorithm/shift_right.h" }
      module shuffle                  { private header "__algorithm/shuffle.h" }
      module sift_down                { private header "__algorithm/sift_down.h" }
      module sort                     { private header "__algorithm/sort.h" }
      module sort_heap                { private header "__algorithm/sort_heap.h" }
      module stable_partition         { private header "__algorithm/stable_partition.h" }
      module stable_sort              { private header "__algorithm/stable_sort.h" }
      module swap_ranges              { private header "__algorithm/swap_ranges.h" }
      module transform                { private header "__algorithm/transform.h" }
      module unique                   { private header "__algorithm/unique.h" }
      module unique_copy              { private header "__algorithm/unique_copy.h" }
      module unwrap_iter              { private header "__algorithm/unwrap_iter.h" }
      module upper_bound              { private header "__algorithm/upper_bound.h" }
    }
  }
  module any {
    header "any"
    export *
  }
  module array {
    header "array"
    export initializer_list
    export *
  }
  module atomic {
    header "atomic"
    export *
  }
  module barrier {
    requires cplusplus14
    header "barrier"
    export *
  }
  module bit {
    header "bit"
    export *

    module __bit {
      module bit_cast { private header "__bit/bit_cast.h" }
      module byteswap { private header "__bit/byteswap.h" }
    }
  }
  module bitset {
    header "bitset"
    export string
    export iosfwd
    export *
  }
  // No submodule for cassert. It fundamentally needs repeated, textual inclusion.
  module charconv {
    header "charconv"
    export *

    module __charconv {
      module chars_format      { private header "__charconv/chars_format.h" }
      module from_chars_result { private header "__charconv/from_chars_result.h" }
      module to_chars_result   { private header "__charconv/to_chars_result.h" }
    }

  }
  module chrono {
    header "chrono"
    export *
  }
  module codecvt {
    header "codecvt"
    export *
  }
  module compare {
    header "compare"
    export *

    module __compare {
      module common_comparison_category { private header "__compare/common_comparison_category.h" }
      module compare_three_way          { private header "__compare/compare_three_way.h" }
      module compare_three_way_result   { private header "__compare/compare_three_way_result.h" }
      module is_eq                      { private header "__compare/is_eq.h" }
      module ordering                   { private header "__compare/ordering.h" }
      module partial_order              { private header "__compare/partial_order.h" }
      module strong_order               { private header "__compare/strong_order.h" }
      module synth_three_way            { private header "__compare/synth_three_way.h" }
      module three_way_comparable       { private header "__compare/three_way_comparable.h" }
      module weak_order                 { private header "__compare/weak_order.h" }
    }
  }
  module complex {
    header "complex"
    export *
  }
  module concepts {
    header "concepts"
    export *

    module __concepts {
      module arithmetic                 { private header "__concepts/arithmetic.h" }
      module assignable                 { private header "__concepts/assignable.h" }
      module boolean_testable           { private header "__concepts/boolean_testable.h" }
      module class_or_enum              { private header "__concepts/class_or_enum.h" }
      module common_reference_with      { private header "__concepts/common_reference_with.h" }
      module common_with                { private header "__concepts/common_with.h" }
      module constructible              { private header "__concepts/constructible.h" }
      module convertible_to             { private header "__concepts/convertible_to.h" }
      module copyable                   { private header "__concepts/copyable.h" }
      module derived_from               { private header "__concepts/derived_from.h" }
      module destructible               { private header "__concepts/destructible.h" }
      module different_from             { private header "__concepts/different_from.h" }
      module equality_comparable        { private header "__concepts/equality_comparable.h" }
      module invocable                  { private header "__concepts/invocable.h" }
      module movable                    { private header "__concepts/movable.h" }
      module predicate                  { private header "__concepts/predicate.h" }
      module regular                    { private header "__concepts/regular.h" }
      module relation                   { private header "__concepts/relation.h" }
      module same_as                    { private header "__concepts/same_as.h" }
      module semiregular                { private header "__concepts/semiregular.h" }
      module swappable                  { private header "__concepts/swappable.h" }
      module totally_ordered            { private header "__concepts/totally_ordered.h" }
    }
  }
  module condition_variable {
    header "condition_variable"
    export *
  }
  module coroutine {
    requires coroutines
    header "coroutine"
    export compare
    export *

    module __coroutine {
      module coroutine_handle           { private header "__coroutine/coroutine_handle.h" }
      module coroutine_traits           { private header "__coroutine/coroutine_traits.h" }
      module trivial_awaitables         { private header "__coroutine/trivial_awaitables.h" }
      module noop_coroutine_handle      { private header "__coroutine/noop_coroutine_handle.h" }
    }
  }
  module deque {
    header "deque"
    export initializer_list
    export *
  }
  module exception {
    header "exception"
    export *
  }
  module execution {
    header "execution"
    export *
  }
  module filesystem {
    header "filesystem"
    export *
  }
  module format {
    header "format"
    export *

    module __format {
      module format_arg             { private header "__format/format_arg.h" }
      module format_args            { private header "__format/format_args.h" }
      module format_context {
        private header "__format/format_context.h"
        export optional
        export locale
      }
      module format_error           { private header "__format/format_error.h" }
      module format_fwd             { private header "__format/format_fwd.h" }
      module format_parse_context   { private header "__format/format_parse_context.h" }
      module format_string          { private header "__format/format_string.h" }
      module format_to_n_result     { private header "__format/format_to_n_result.h" }
      module formatter              { private header "__format/formatter.h" }
      module formatter_bool         { private header "__format/formatter_bool.h" }
      module formatter_char         { private header "__format/formatter_char.h" }
      module formatter_integer      { private header "__format/formatter_integer.h" }
      module formatter_integral     { private header "__format/formatter_integral.h" }
      module formatter_string       { private header "__format/formatter_string.h" }
      module parser_std_format_spec { private header "__format/parser_std_format_spec.h" }
    }
  }
  module forward_list {
    header "forward_list"
    export initializer_list
    export *
  }
  module fstream {
    header "fstream"
    export *
  }
  module functional {
    header "functional"
    export *

    module __functional {
      module binary_function            { private header "__functional/binary_function.h" }
      module binary_negate              { private header "__functional/binary_negate.h" }
      module bind                       { private header "__functional/bind.h" }
      module bind_back                  { private header "__functional/bind_back.h" }
      module bind_front                 { private header "__functional/bind_front.h" }
      module binder1st                  { private header "__functional/binder1st.h" }
      module binder2nd                  { private header "__functional/binder2nd.h" }
      module compose                    { private header "__functional/compose.h" }
      module default_searcher           { private header "__functional/default_searcher.h" }
      module function                   { private header "__functional/function.h" }
      module hash                       { private header "__functional/hash.h" }
      module identity                   { private header "__functional/identity.h" }
      module invoke                     { private header "__functional/invoke.h" }
      module is_transparent             { private header "__functional/is_transparent.h" }
      module mem_fn                     { private header "__functional/mem_fn.h" }
      module mem_fun_ref                { private header "__functional/mem_fun_ref.h" }
      module not_fn                     { private header "__functional/not_fn.h" }
      module operations                 { private header "__functional/operations.h" }
      module perfect_forward            { private header "__functional/perfect_forward.h" }
      module pointer_to_binary_function { private header "__functional/pointer_to_binary_function.h" }
      module pointer_to_unary_function  { private header "__functional/pointer_to_unary_function.h" }
      module ranges_operations          { private header "__functional/ranges_operations.h" }
      module reference_wrapper          { private header "__functional/reference_wrapper.h" }
      module unary_function             { private header "__functional/unary_function.h" }
      module unary_negate               { private header "__functional/unary_negate.h" }
      module unwrap_ref                 { private header "__functional/unwrap_ref.h" }
      module weak_result_type           { private header "__functional/weak_result_type.h" }
    }
  }
  module future {
    header "future"
    export *
  }
  module initializer_list {
    header "initializer_list"
    export *
  }
  module iomanip {
    header "iomanip"
    export *
  }
  module ios {
    header "ios"
    export iosfwd
    export *
  }
  module iosfwd {
    header "iosfwd"
    export *
  }
  module iostream {
    header "iostream"
    export ios
    export streambuf
    export istream
    export ostream
    export *
  }
  module istream {
    header "istream"
    // FIXME: should re-export ios, streambuf?
    export *
  }
  module iterator {
    header "iterator"
    export *

    module __iterator {
      module access                { private header "__iterator/access.h" }
      module advance               {
        private header "__iterator/advance.h"
        export __function_like
      }
      module back_insert_iterator  { private header "__iterator/back_insert_iterator.h" }
      module common_iterator       { private header "__iterator/common_iterator.h" }
      module concepts              { private header "__iterator/concepts.h" }
      module counted_iterator      { private header "__iterator/counted_iterator.h" }
      module data                  { private header "__iterator/data.h" }
      module default_sentinel      { private header "__iterator/default_sentinel.h" }
      module distance              { private header "__iterator/distance.h" }
      module empty                 { private header "__iterator/empty.h" }
      module erase_if_container    { private header "__iterator/erase_if_container.h" }
      module front_insert_iterator { private header "__iterator/front_insert_iterator.h" }
      module incrementable_traits  { private header "__iterator/incrementable_traits.h" }
      module insert_iterator       { private header "__iterator/insert_iterator.h" }
      module istream_iterator      { private header "__iterator/istream_iterator.h" }
      module istreambuf_iterator   { private header "__iterator/istreambuf_iterator.h" }
      module iter_move             { private header "__iterator/iter_move.h" }
      module iter_swap             { private header "__iterator/iter_swap.h" }
      module iterator              { private header "__iterator/iterator.h" }
      module iterator_traits       { private header "__iterator/iterator_traits.h" }
      module move_iterator         { private header "__iterator/move_iterator.h" }
      module next                  {
        private header "__iterator/next.h"
        export __function_like
      }
      module ostream_iterator      { private header "__iterator/ostream_iterator.h" }
      module ostreambuf_iterator   { private header "__iterator/ostreambuf_iterator.h" }
      module prev                  {
        private header "__iterator/prev.h"
        export __function_like
      }
      module projected             { private header "__iterator/projected.h" }
      module readable_traits       { private header "__iterator/readable_traits.h" }
      module reverse_access        { private header "__iterator/reverse_access.h" }
      module reverse_iterator      { private header "__iterator/reverse_iterator.h" }
      module size                  { private header "__iterator/size.h" }
      module unreachable_sentinel  { private header "__iterator/unreachable_sentinel.h" }
      module wrap_iter             { private header "__iterator/wrap_iter.h" }
    }
  }
  module latch {
    requires cplusplus14
    header "latch"
    export *
  }
  module limits {
    header "limits"
    export *
  }
  module list {
    header "list"
    export initializer_list
    export *
  }
  module locale {
    header "locale"
    export *
  }
  module map {
    header "map"
    export initializer_list
    export *
  }
  module memory {
    header "memory"
    export *

    module __memory {
      module addressof                { private header "__memory/addressof.h" }
      module allocation_guard         { private header "__memory/allocation_guard.h" }
      module allocator                { private header "__memory/allocator.h" }
      module allocator_arg_t          { private header "__memory/allocator_arg_t.h" }
      module allocator_traits         { private header "__memory/allocator_traits.h" }
      module auto_ptr                 { private header "__memory/auto_ptr.h" }
      module compressed_pair          { private header "__memory/compressed_pair.h" }
      module concepts                 { private header "__memory/concepts.h" }
      module construct_at             { private header "__memory/construct_at.h" }
      module pointer_traits           { private header "__memory/pointer_traits.h" }
      module raw_storage_iterator     { private header "__memory/raw_storage_iterator.h" }
      module shared_ptr               { private header "__memory/shared_ptr.h" }
      module temporary_buffer         { private header "__memory/temporary_buffer.h" }
      module uninitialized_algorithms { private header "__memory/uninitialized_algorithms.h" }
      module unique_ptr               { private header "__memory/unique_ptr.h" }
      module uses_allocator           { private header "__memory/uses_allocator.h" }
    }
  }
  module mutex {
    header "mutex"
    export *
  }
  module new {
    header "new"
    export *
  }
  module numbers {
    header "numbers"
    export *
  }
  module numeric {
    header "numeric"
    export *

    module __numeric {
      module accumulate               { private header "__numeric/accumulate.h" }
      module adjacent_difference      { private header "__numeric/adjacent_difference.h" }
      module exclusive_scan           { private header "__numeric/exclusive_scan.h" }
      module gcd_lcm                  { private header "__numeric/gcd_lcm.h" }
      module inclusive_scan           { private header "__numeric/inclusive_scan.h" }
      module inner_product            { private header "__numeric/inner_product.h" }
      module iota                     { private header "__numeric/iota.h" }
      module midpoint                 { private header "__numeric/midpoint.h" }
      module partial_sum              { private header "__numeric/partial_sum.h" }
      module reduce                   { private header "__numeric/reduce.h" }
      module transform_exclusive_scan { private header "__numeric/transform_exclusive_scan.h" }
      module transform_inclusive_scan { private header "__numeric/transform_inclusive_scan.h" }
      module transform_reduce         { private header "__numeric/transform_reduce.h" }
    }
  }
  module optional {
    header "optional"
    export *
  }
  module ostream {
    header "ostream"
    // FIXME: should re-export ios, streambuf?
    export *
  }
  module queue {
    header "queue"
    export initializer_list
    export *
  }
  module random {
    header "random"
    export initializer_list
    export *

    module __random {
      module bernoulli_distribution          { private header "__random/bernoulli_distribution.h" }
      module binomial_distribution           { private header "__random/binomial_distribution.h" }
      module cauchy_distribution             { private header "__random/cauchy_distribution.h" }
      module chi_squared_distribution        { private header "__random/chi_squared_distribution.h" }
      module clamp_to_integral               { private header "__random/clamp_to_integral.h" }
      module default_random_engine           { private header "__random/default_random_engine.h" }
      module discard_block_engine            { private header "__random/discard_block_engine.h" }
      module discrete_distribution           { private header "__random/discrete_distribution.h" }
      module exponential_distribution        { private header "__random/exponential_distribution.h" }
      module extreme_value_distribution      { private header "__random/extreme_value_distribution.h" }
      module fisher_f_distribution           { private header "__random/fisher_f_distribution.h" }
      module gamma_distribution              { private header "__random/gamma_distribution.h" }
      module generate_canonical              { private header "__random/generate_canonical.h" }
      module geometric_distribution          { private header "__random/geometric_distribution.h" }
      module independent_bits_engine         { private header "__random/independent_bits_engine.h" }
      module is_seed_sequence                { private header "__random/is_seed_sequence.h" }
      module knuth_b                         { private header "__random/knuth_b.h" }
      module linear_congruential_engine      { private header "__random/linear_congruential_engine.h" }
      module log2                            { private header "__random/log2.h" }
      module lognormal_distribution          { private header "__random/lognormal_distribution.h" }
      module mersenne_twister_engine         { private header "__random/mersenne_twister_engine.h" }
      module negative_binomial_distribution  { private header "__random/negative_binomial_distribution.h" }
      module normal_distribution             { private header "__random/normal_distribution.h" }
      module piecewise_constant_distribution { private header "__random/piecewise_constant_distribution.h" }
      module piecewise_linear_distribution   { private header "__random/piecewise_linear_distribution.h" }
      module poisson_distribution            { private header "__random/poisson_distribution.h" }
      module random_device                   { private header "__random/random_device.h" }
      module ranlux                          { private header "__random/ranlux.h" }
      module seed_seq                        { private header "__random/seed_seq.h" }
      module shuffle_order_engine            { private header "__random/shuffle_order_engine.h" }
      module student_t_distribution          { private header "__random/student_t_distribution.h" }
      module subtract_with_carry_engine      { private header "__random/subtract_with_carry_engine.h" }
      module uniform_int_distribution        { private header "__random/uniform_int_distribution.h" }
      module uniform_random_bit_generator    { private header "__random/uniform_random_bit_generator.h" }
      module uniform_real_distribution       { private header "__random/uniform_real_distribution.h" }
      module weibull_distribution            { private header "__random/weibull_distribution.h" }
    }
  }
  module ranges {
    header "ranges"
    export compare
    export initializer_list
    export iterator
    export *

    module __ranges {
      module access                 { private header "__ranges/access.h" }
      module all                    {
        private header "__ranges/all.h"
        export functional.__functional.compose
        export functional.__functional.perfect_forward
      }
      module common_view            { private header "__ranges/common_view.h" }
      module concepts               { private header "__ranges/concepts.h" }
      module copyable_box           { private header "__ranges/copyable_box.h" }
      module counted                { private header "__ranges/counted.h" }
      module dangling               { private header "__ranges/dangling.h" }
      module data                   { private header "__ranges/data.h" }
      module drop_view              { private header "__ranges/drop_view.h" }
      module empty                  { private header "__ranges/empty.h" }
      module empty_view             { private header "__ranges/empty_view.h" }
      module enable_borrowed_range  { private header "__ranges/enable_borrowed_range.h" }
      module enable_view            { private header "__ranges/enable_view.h" }
      module iota_view              { private header "__ranges/iota_view.h" }
      module join_view              { private header "__ranges/join_view.h" }
      module non_propagating_cache  { private header "__ranges/non_propagating_cache.h" }
      module range_adaptor          { private header "__ranges/range_adaptor.h" }
      module ref_view               { private header "__ranges/ref_view.h" }
      module reverse_view           { private header "__ranges/reverse_view.h" }
      module size                   { private header "__ranges/size.h" }
      module single_view            { private header "__ranges/single_view.h" }
      module subrange               { private header "__ranges/subrange.h" }
      module take_view              { private header "__ranges/take_view.h" }
      module transform_view         {
        private header "__ranges/transform_view.h"
        export functional.__functional.bind_back
        export functional.__functional.perfect_forward
      }
      module view_interface         { private header "__ranges/view_interface.h" }
    }
  }
  module ratio {
    header "ratio"
    export *
  }
  module regex {
    header "regex"
    export initializer_list
    export *
  }
  module scoped_allocator {
    header "scoped_allocator"
    export *
  }
  module semaphore {
    requires cplusplus14
    header "semaphore"
    export *
  }
  module set {
    header "set"
    export initializer_list
    export *
  }
  module shared_mutex {
    header "shared_mutex"
    export version
  }
  module span {
    header "span"
    export ranges.__ranges.enable_borrowed_range
    export version
  }
  module sstream {
    header "sstream"
    // FIXME: should re-export istream, ostream, ios, streambuf, string?
    export *
  }
  module stack {
    header "stack"
    export initializer_list
    export *
  }
  module stdexcept {
    header "stdexcept"
    export *
  }
  module streambuf {
    header "streambuf"
    export *
  }
  module string {
    header "string"
    export initializer_list
    export string_view
    export __string
    export *
  }
  module string_view {
    header "string_view"
    export initializer_list
    export __string
    export *
  }
  module strstream {
    header "strstream"
    export *
  }
  module system_error {
    header "system_error"
    export *
  }
  module thread {
    header "thread"
    export *

    module __thread {
      module poll_with_backoff { private header "__thread/poll_with_backoff.h" }
    }
  }
  module tuple {
    header "tuple"
    export *
  }
  module type_traits {
    header "type_traits"
    export functional.__functional.unwrap_ref
    export *
  }
  module typeindex {
    header "typeindex"
    export *
  }
  module typeinfo {
    header "typeinfo"
    export *
  }
  module unordered_map {
    header "unordered_map"
    export initializer_list
    export *
  }
  module unordered_set {
    header "unordered_set"
    export initializer_list
    export *
  }
  module utility {
    header "utility"
    export initializer_list
    export *

    module __utility {
      module as_const            { private header "__utility/as_const.h" }
      module cmp                 { private header "__utility/cmp.h" }
      module decay_copy          { private header "__utility/decay_copy.h" }
      module declval             { private header "__utility/declval.h" }
      module exchange            { private header "__utility/exchange.h" }
      module forward             { private header "__utility/forward.h" }
      module in_place            { private header "__utility/in_place.h" }
      module integer_sequence    { private header "__utility/integer_sequence.h" }
      module move                { private header "__utility/move.h" }
      module pair                { private header "__utility/pair.h" }
      module piecewise_construct { private header "__utility/piecewise_construct.h" }
      module priority_tag        { private header "__utility/priority_tag.h" }
      module rel_ops             { private header "__utility/rel_ops.h" }
      module swap                { private header "__utility/swap.h" }
      module to_underlying       { private header "__utility/to_underlying.h" }
    }
  }
  module valarray {
    header "valarray"
    export initializer_list
    export *
  }
  module variant {
    header "variant"
    export *

    module __variant {
      module monostate { private header "__variant/monostate.h" }
    }
  }
  module vector {
    header "vector"
    export initializer_list
    export *
  }
  module version {
    header "version"
    export *
  }

  // __config not modularised due to a bug in Clang
  // FIXME: These should be private.
  module __availability      { private header "__availability"      export * }
  module __bit_reference     { private header "__bit_reference"     export * }
  module __bits              { private header "__bits"              export * }
  module __debug             {         header "__debug"             export * }
  module __errc              { private header "__errc"              export * }
  module __function_like     { private header "__function_like.h"   export * }
  module __hash_table        {         header "__hash_table"        export * }
  module __locale            { private header "__locale"            export * }
  module __mbstate           { private header "__mbstate_t.h"       export * }
  module __mutex_base        { private header "__mutex_base"        export * }
  module __node_handle       { private header "__node_handle"       export * }
  module __nullptr           {         header "__nullptr"           export * }
  module __split_buffer      { private header "__split_buffer"      export * }
  module __std_stream        { private header "__std_stream"        export * }
  module __string            { private header "__string"            export * }
  module __threading_support {         header "__threading_support" export * }
  module __tree              {         header "__tree"              export * }
  module __tuple             { private header "__tuple"             export * }
  module __undef_macros      {         header "__undef_macros"      export * }

  module experimental {
    requires cplusplus11

    module algorithm {
      header "experimental/algorithm"
      export *
    }
     module coroutine {
      requires coroutines
      header "experimental/coroutine"
      export *
    }
    module deque {
      header "experimental/deque"
      export *
    }
    module filesystem {
      header "experimental/filesystem"
      export *
    }
    module forward_list {
      header "experimental/forward_list"
      export *
    }
    module functional {
      header "experimental/functional"
      export *
    }
    module iterator {
      header "experimental/iterator"
      export *
    }
    module list {
      header "experimental/list"
      export *
    }
    module map {
      header "experimental/map"
      export *
    }
    module memory_resource {
      header "experimental/memory_resource"
      export *
    }
    module propagate_const {
      header "experimental/propagate_const"
      export *
    }
    module regex {
      header "experimental/regex"
      export *
    }
    module simd {
      header "experimental/simd"
      export *
    }
    module set {
      header "experimental/set"
      export *
    }
    module span {
      header "span"
      export *
    }
    module string {
      header "experimental/string"
      export *
    }
    module type_traits {
      header "experimental/type_traits"
      export *
    }
    module unordered_map {
      header "experimental/unordered_map"
      export *
    }
    module unordered_set {
      header "experimental/unordered_set"
      export *
    }
    module utility {
      header "experimental/utility"
      export *
    }
    module vector {
      header "experimental/vector"
      export *
    }
    // FIXME these should be private
    module __memory {
      header "experimental/__memory"
      export *
    }
  } // end experimental
}