• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
1// This module contains headers related to the configuration of the library. These headers
2// are free of any dependency on the rest of libc++.
3module std_config [system] {
4  textual header "__config"
5  textual header "__configuration/abi.h"
6  textual header "__configuration/availability.h"
7  textual header "__configuration/compiler.h"
8  textual header "__configuration/language.h"
9  textual header "__configuration/platform.h"
10  textual header "version"
11}
12
13module std_core [system] {
14  module cstddef {
15    module byte         { header "__cstddef/byte.h" }
16    module max_align_t  {
17      header "__cstddef/max_align_t.h"
18      export *
19    }
20    module nullptr_t    { header "__cstddef/nullptr_t.h" }
21    module ptrdiff_t    { header "__cstddef/ptrdiff_t.h" }
22    module size_t       { header "__cstddef/size_t.h" }
23  }
24
25  module cstdint {
26    header "cstdint"
27    export *
28  }
29
30  module fwd {
31    module byte         { header "__fwd/byte.h" }
32    module functional   { header "__fwd/functional.h" }
33    module pair         { header "__fwd/pair.h" }
34    module tuple        { header "__fwd/tuple.h" }
35  }
36
37  module limits {
38    header "limits"
39    export *
40  }
41
42  module math {
43    module abs                              { header "__math/abs.h" }
44    module copysign                         { header "__math/copysign.h" }
45    module error_functions                  { header "__math/error_functions.h" }
46    module exponential_functions            { header "__math/exponential_functions.h" }
47    module fdim                             { header "__math/fdim.h" }
48    module fma                              { header "__math/fma.h" }
49    module gamma                            { header "__math/gamma.h" }
50    module hyperbolic_functions             { header "__math/hyperbolic_functions.h" }
51    module hypot                            { header "__math/hypot.h" }
52    module inverse_hyperbolic_functions     { header "__math/inverse_hyperbolic_functions.h" }
53    module inverse_trigonometric_functions  { header "__math/inverse_trigonometric_functions.h" }
54    module logarithms                       { header "__math/logarithms.h" }
55    module min_max                          { header "__math/min_max.h" }
56    module modulo                           { header "__math/modulo.h" }
57    module remainder                        { header "__math/remainder.h" }
58    module roots                            { header "__math/roots.h" }
59    module rounding_functions               { header "__math/rounding_functions.h" }
60    module special_functions                { header "__math/special_functions.h" }
61    module traits                           { header "__math/traits.h" }
62    module trigonometric_functions          { header "__math/trigonometric_functions.h" }
63  }
64
65  module type_traits {
66    module add_cv_quals                               { header "__type_traits/add_cv_quals.h" }
67    module add_lvalue_reference                       { header "__type_traits/add_lvalue_reference.h" }
68    module add_pointer                                { header "__type_traits/add_pointer.h" }
69    module add_rvalue_reference                       { header "__type_traits/add_rvalue_reference.h" }
70    module aligned_storage                            { header "__type_traits/aligned_storage.h" }
71    module aligned_union                              { header "__type_traits/aligned_union.h" }
72    module alignment_of                               { header "__type_traits/alignment_of.h" }
73    module can_extract_key                            { header "__type_traits/can_extract_key.h" }
74    module common_reference                           { header "__type_traits/common_reference.h" }
75    module common_type {
76      header "__type_traits/common_type.h"
77      // We need to export those because common_type inherits from either of those based on __builtin_common_type.
78      export std_core.type_traits.type_identity
79      export std_core.utility_core.empty
80    }
81    module conditional                                { header "__type_traits/conditional.h" }
82    module conjunction                                { header "__type_traits/conjunction.h" }
83    module container_traits                           { header "__type_traits/container_traits.h" }
84    module copy_cv                                    { header "__type_traits/copy_cv.h" }
85    module copy_cvref                                 { header "__type_traits/copy_cvref.h" }
86    module datasizeof                                 { header "__type_traits/datasizeof.h" }
87    module decay                                      { header "__type_traits/decay.h" }
88    module dependent_type                             { header "__type_traits/dependent_type.h" }
89    module desugars_to                                { header "__type_traits/desugars_to.h" }
90    module detected_or                                { header "__type_traits/detected_or.h" }
91    module disjunction                                { header "__type_traits/disjunction.h" }
92    module enable_if                                  { header "__type_traits/enable_if.h" }
93    module extent                                     { header "__type_traits/extent.h" }
94    module has_unique_object_representation           { header "__type_traits/has_unique_object_representation.h" }
95    module has_virtual_destructor                     { header "__type_traits/has_virtual_destructor.h" }
96    module integral_constant                          { header "__type_traits/integral_constant.h" }
97    module invoke                                     { header "__type_traits/invoke.h" }
98    module is_abstract {
99      header "__type_traits/is_abstract.h"
100      export std_core.type_traits.integral_constant
101    }
102    module is_aggregate {
103      header "__type_traits/is_aggregate.h"
104      export std_core.type_traits.integral_constant
105    }
106    module is_allocator {
107      header "__type_traits/is_allocator.h"
108      export std_core.type_traits.integral_constant
109    }
110    module is_always_bitcastable {
111      header "__type_traits/is_always_bitcastable.h"
112      export std_core.type_traits.integral_constant
113    }
114    module is_arithmetic {
115      header "__type_traits/is_arithmetic.h"
116      export std_core.type_traits.integral_constant
117    }
118    module is_array {
119      header "__type_traits/is_array.h"
120      export std_core.type_traits.integral_constant
121    }
122    module is_assignable {
123      header "__type_traits/is_assignable.h"
124      export std_core.type_traits.integral_constant
125    }
126    module is_base_of {
127      header "__type_traits/is_base_of.h"
128      export std_core.type_traits.integral_constant
129    }
130    module is_bounded_array {
131      header "__type_traits/is_bounded_array.h"
132      export std_core.type_traits.integral_constant
133    }
134    module is_callable {
135      header "__type_traits/is_callable.h"
136      export std_core.type_traits.integral_constant
137    }
138    module is_char_like_type {
139      header "__type_traits/is_char_like_type.h"
140      export std_core.type_traits.integral_constant
141    }
142    module is_class {
143      header "__type_traits/is_class.h"
144      export std_core.type_traits.integral_constant
145    }
146    module is_compound {
147      header "__type_traits/is_compound.h"
148      export std_core.type_traits.integral_constant
149    }
150    module is_const {
151      header "__type_traits/is_const.h"
152      export std_core.type_traits.integral_constant
153    }
154    module is_constant_evaluated {
155      header "__type_traits/is_constant_evaluated.h"
156      export std_core.type_traits.integral_constant
157    }
158    module is_constructible {
159      header "__type_traits/is_constructible.h"
160      export std_core.type_traits.integral_constant
161    }
162    module is_convertible {
163      header "__type_traits/is_convertible.h"
164      export std_core.type_traits.integral_constant
165    }
166    module is_core_convertible {
167      header "__type_traits/is_core_convertible.h"
168      export std_core.type_traits.integral_constant
169    }
170    module is_destructible {
171      header "__type_traits/is_destructible.h"
172      export std_core.type_traits.integral_constant
173    }
174    module is_empty {
175      header "__type_traits/is_empty.h"
176      export std_core.type_traits.integral_constant
177    }
178    module is_enum {
179      header "__type_traits/is_enum.h"
180      export std_core.type_traits.integral_constant
181    }
182    module is_equality_comparable {
183      header "__type_traits/is_equality_comparable.h"
184      export std_core.type_traits.integral_constant
185    }
186    module is_execution_policy {
187      header "__type_traits/is_execution_policy.h"
188      export std_core.type_traits.integral_constant
189    }
190    module is_final {
191      header "__type_traits/is_final.h"
192      export std_core.type_traits.integral_constant
193    }
194    module is_floating_point {
195      header "__type_traits/is_floating_point.h"
196      export std_core.type_traits.integral_constant
197    }
198    module is_function {
199      header "__type_traits/is_function.h"
200      export std_core.type_traits.integral_constant
201    }
202    module is_fundamental {
203      header "__type_traits/is_fundamental.h"
204      export std_core.type_traits.integral_constant
205    }
206    module is_implicit_lifetime {
207      header "__type_traits/is_implicit_lifetime.h"
208      export std_core.type_traits.integral_constant
209    }
210    module is_implicitly_default_constructible {
211      header "__type_traits/is_implicitly_default_constructible.h"
212      export std_core.type_traits.integral_constant
213    }
214    module is_integral {
215      header "__type_traits/is_integral.h"
216      export std_core.type_traits.integral_constant
217    }
218    module is_literal_type {
219      header "__type_traits/is_literal_type.h"
220      export std_core.type_traits.integral_constant
221    }
222    module is_member_pointer {
223      header "__type_traits/is_member_pointer.h"
224      export std_core.type_traits.integral_constant
225    }
226    module is_nothrow_assignable {
227      header "__type_traits/is_nothrow_assignable.h"
228      export std_core.type_traits.integral_constant
229    }
230    module is_nothrow_constructible {
231      header "__type_traits/is_nothrow_constructible.h"
232      export std_core.type_traits.integral_constant
233    }
234    module is_nothrow_convertible {
235      header "__type_traits/is_nothrow_convertible.h"
236      export std_core.type_traits.integral_constant
237    }
238    module is_nothrow_destructible {
239      header "__type_traits/is_nothrow_destructible.h"
240      export std_core.type_traits.integral_constant
241    }
242    module is_null_pointer {
243      header "__type_traits/is_null_pointer.h"
244      export std_core.type_traits.integral_constant
245    }
246    module is_object {
247      header "__type_traits/is_object.h"
248      export std_core.type_traits.integral_constant
249    }
250    module is_pod {
251      header "__type_traits/is_pod.h"
252      export std_core.type_traits.integral_constant
253    }
254    module is_pointer {
255      header "__type_traits/is_pointer.h"
256      export std_core.type_traits.integral_constant
257    }
258    module is_polymorphic {
259      header "__type_traits/is_polymorphic.h"
260      export std_core.type_traits.integral_constant
261    }
262    module is_primary_template {
263      header "__type_traits/is_primary_template.h"
264      export std_core.type_traits.integral_constant
265    }
266    module is_reference_wrapper {
267      header "__type_traits/is_reference_wrapper.h"
268      export std_core.type_traits.integral_constant
269    }
270    module is_reference {
271      header "__type_traits/is_reference.h"
272      export std_core.type_traits.integral_constant
273    }
274    module is_referenceable {
275      header "__type_traits/is_referenceable.h"
276      export std_core.type_traits.integral_constant
277    }
278    module is_same {
279      header "__type_traits/is_same.h"
280      export std_core.type_traits.integral_constant
281    }
282    module is_scalar {
283      header "__type_traits/is_scalar.h"
284      export std_core.type_traits.integral_constant
285    }
286    module is_signed_integer {
287      header "__type_traits/is_signed_integer.h"
288      export std_core.type_traits.integral_constant
289    }
290    module is_signed {
291      header "__type_traits/is_signed.h"
292      export std_core.type_traits.integral_constant
293    }
294    module is_specialization {
295      header "__type_traits/is_specialization.h"
296      export std_core.type_traits.integral_constant
297    }
298    module is_standard_layout {
299      header "__type_traits/is_standard_layout.h"
300      export std_core.type_traits.integral_constant
301    }
302    module is_swappable {
303      header "__type_traits/is_swappable.h"
304      export std_core.type_traits.integral_constant
305    }
306    module is_trivial {
307      header "__type_traits/is_trivial.h"
308      export std_core.type_traits.integral_constant
309    }
310    module is_trivially_assignable {
311      header "__type_traits/is_trivially_assignable.h"
312      export std_core.type_traits.integral_constant
313    }
314    module is_trivially_constructible {
315      header "__type_traits/is_trivially_constructible.h"
316      export std_core.type_traits.integral_constant
317    }
318    module is_trivially_copyable {
319      header "__type_traits/is_trivially_copyable.h"
320      export std_core.type_traits.integral_constant
321    }
322    module is_trivially_destructible {
323      header "__type_traits/is_trivially_destructible.h"
324      export std_core.type_traits.integral_constant
325    }
326    module is_trivially_lexicographically_comparable {
327      header "__type_traits/is_trivially_lexicographically_comparable.h"
328      export std_core.type_traits.integral_constant
329    }
330    module is_trivially_relocatable {
331      header "__type_traits/is_trivially_relocatable.h"
332      export std_core.type_traits.integral_constant
333    }
334    module is_unbounded_array {
335      header "__type_traits/is_unbounded_array.h"
336      export std_core.type_traits.integral_constant
337    }
338    module is_union {
339      header "__type_traits/is_union.h"
340      export std_core.type_traits.integral_constant
341    }
342    module is_unsigned_integer {
343      header "__type_traits/is_unsigned_integer.h"
344      export std_core.type_traits.integral_constant
345    }
346    module is_unsigned {
347      header "__type_traits/is_unsigned.h"
348      export std_core.type_traits.integral_constant
349    }
350    module is_valid_expansion {
351      header "__type_traits/is_valid_expansion.h"
352      export std_core.type_traits.integral_constant
353    }
354    module is_void {
355      header "__type_traits/is_void.h"
356      export std_core.type_traits.integral_constant
357    }
358    module is_volatile {
359      header "__type_traits/is_volatile.h"
360      export std_core.type_traits.integral_constant
361    }
362    module lazy                                       { header "__type_traits/lazy.h" }
363    module make_32_64_or_128_bit                      { header "__type_traits/make_32_64_or_128_bit.h" }
364    module make_const_lvalue_ref                      { header "__type_traits/make_const_lvalue_ref.h" }
365    module make_signed                                { header "__type_traits/make_signed.h" }
366    module make_unsigned                              { header "__type_traits/make_unsigned.h" }
367    module maybe_const                                { header "__type_traits/maybe_const.h" }
368    module nat                                        { header "__type_traits/nat.h" }
369    module negation                                   { header "__type_traits/negation.h" }
370    module promote                                    { header "__type_traits/promote.h" }
371    module rank                                       { header "__type_traits/rank.h" }
372    module remove_all_extents                         { header "__type_traits/remove_all_extents.h" }
373    module remove_const_ref                           { header "__type_traits/remove_const_ref.h" }
374    module remove_const                               { header "__type_traits/remove_const.h" }
375    module remove_cv                                  { header "__type_traits/remove_cv.h" }
376    module remove_cvref                               { header "__type_traits/remove_cvref.h" }
377    module remove_extent                              { header "__type_traits/remove_extent.h" }
378    module remove_pointer                             { header "__type_traits/remove_pointer.h" }
379    module remove_reference                           { header "__type_traits/remove_reference.h" }
380    module remove_volatile                            { header "__type_traits/remove_volatile.h" }
381    module result_of                                  { header "__type_traits/result_of.h" }
382    module strip_signature                            { header "__type_traits/strip_signature.h" }
383    module type_identity                              { header "__type_traits/type_identity.h" }
384    module type_list                                  { header "__type_traits/type_list.h" }
385    module underlying_type                            { header "__type_traits/underlying_type.h" }
386    module unwrap_ref                                 { header "__type_traits/unwrap_ref.h" }
387    module void_t                                     { header "__type_traits/void_t.h" }
388
389    header "type_traits"
390    export *
391  } // module type_traits
392
393  // Only the truly dependency-free parts of __utility are here
394  module utility_core {
395    module declval  { header "__utility/declval.h" }
396    module empty    { header "__utility/empty.h" }
397    module forward  { header "__utility/forward.h" }
398  }
399} // module std_core
400
401module std [system] {
402  module algorithm {
403    module adjacent_find                          { header "__algorithm/adjacent_find.h" }
404    module all_of                                 { header "__algorithm/all_of.h" }
405    module any_of                                 { header "__algorithm/any_of.h" }
406    module binary_search                          { header "__algorithm/binary_search.h" }
407    module clamp                                  { header "__algorithm/clamp.h" }
408    module comp_ref_type                          { header "__algorithm/comp_ref_type.h" }
409    module comp                                   { header "__algorithm/comp.h" }
410    module copy_backward                          { header "__algorithm/copy_backward.h" }
411    module copy_if                                { header "__algorithm/copy_if.h" }
412    module copy_move_common                       { header "__algorithm/copy_move_common.h" }
413    module copy_n                                 { header "__algorithm/copy_n.h" }
414    module copy                                   { header "__algorithm/copy.h" }
415    module count_if                               { header "__algorithm/count_if.h" }
416    module count                                  { header "__algorithm/count.h" }
417    module equal_range                            { header "__algorithm/equal_range.h" }
418    module equal                                  { header "__algorithm/equal.h" }
419    module fill_n                                 { header "__algorithm/fill_n.h" }
420    module fill                                   { header "__algorithm/fill.h" }
421    module find_end                               { header "__algorithm/find_end.h" }
422    module find_first_of                          { header "__algorithm/find_first_of.h" }
423    module find_if_not                            { header "__algorithm/find_if_not.h" }
424    module find_if                                { header "__algorithm/find_if.h" }
425    module find_segment_if                        { header "__algorithm/find_segment_if.h" }
426    module find                                   { header "__algorithm/find.h" }
427    module for_each_n                             { header "__algorithm/for_each_n.h" }
428    module for_each_segment                       { header "__algorithm/for_each_segment.h" }
429    module for_each                               { header "__algorithm/for_each.h" }
430    module generate_n                             { header "__algorithm/generate_n.h" }
431    module generate                               { header "__algorithm/generate.h" }
432    module half_positive                          { header "__algorithm/half_positive.h" }
433    module in_found_result                        { header "__algorithm/in_found_result.h" }
434    module in_fun_result                          { header "__algorithm/in_fun_result.h" }
435    module in_in_out_result                       { header "__algorithm/in_in_out_result.h" }
436    module in_in_result                           { header "__algorithm/in_in_result.h" }
437    module in_out_out_result                      { header "__algorithm/in_out_out_result.h" }
438    module in_out_result                          { header "__algorithm/in_out_result.h" }
439    module includes                               { header "__algorithm/includes.h" }
440    module inplace_merge                          { header "__algorithm/inplace_merge.h" }
441    module is_heap_until                          { header "__algorithm/is_heap_until.h" }
442    module is_heap                                { header "__algorithm/is_heap.h" }
443    module is_partitioned                         { header "__algorithm/is_partitioned.h" }
444    module is_permutation                         { header "__algorithm/is_permutation.h" }
445    module is_sorted_until                        { header "__algorithm/is_sorted_until.h" }
446    module is_sorted                              { header "__algorithm/is_sorted.h" }
447    module iter_swap                              { header "__algorithm/iter_swap.h" }
448    module iterator_operations {
449      header "__algorithm/iterator_operations.h"
450      export std.iterator.advance
451      export std.iterator.distance
452      export std.iterator.iter_move
453      export std.iterator.iter_swap
454      export std.iterator.next
455      export std.iterator.prev
456    }
457    module lexicographical_compare_three_way      { header "__algorithm/lexicographical_compare_three_way.h" }
458    module lexicographical_compare                { header "__algorithm/lexicographical_compare.h" }
459    module lower_bound                            { header "__algorithm/lower_bound.h" }
460    module make_heap                              { header "__algorithm/make_heap.h" }
461    module make_projected                         { header "__algorithm/make_projected.h" }
462    module max_element                            { header "__algorithm/max_element.h" }
463    module max                                    { header "__algorithm/max.h" }
464    module merge                                  { header "__algorithm/merge.h" }
465    module min_element                            { header "__algorithm/min_element.h" }
466    module min_max_result                         { header "__algorithm/min_max_result.h" }
467    module min                                    { header "__algorithm/min.h" }
468    module minmax_element                         { header "__algorithm/minmax_element.h" }
469    module minmax {
470      header "__algorithm/minmax.h"
471      export std.utility.pair // return type
472    }
473    module mismatch {
474      header "__algorithm/mismatch.h"
475      export std.utility.pair // return type
476    }
477    module move_backward                          { header "__algorithm/move_backward.h" }
478    module move                                   { header "__algorithm/move.h" }
479    module next_permutation                       { header "__algorithm/next_permutation.h" }
480    module none_of                                { header "__algorithm/none_of.h" }
481    module nth_element                            { header "__algorithm/nth_element.h" }
482    module partial_sort_copy                      { header "__algorithm/partial_sort_copy.h" }
483    module partial_sort                           { header "__algorithm/partial_sort.h" }
484    module partition_copy                         { header "__algorithm/partition_copy.h" }
485    module partition_point                        { header "__algorithm/partition_point.h" }
486    module partition                              { header "__algorithm/partition.h" }
487    module pop_heap                               { header "__algorithm/pop_heap.h" }
488    module prev_permutation                       { header "__algorithm/prev_permutation.h" }
489    module pstl                                   { header "__algorithm/pstl.h" }
490    module push_heap                              { header "__algorithm/push_heap.h" }
491    module ranges_adjacent_find                   { header "__algorithm/ranges_adjacent_find.h" }
492    module ranges_all_of                          { header "__algorithm/ranges_all_of.h" }
493    module ranges_any_of                          { header "__algorithm/ranges_any_of.h" }
494    module ranges_binary_search {
495      header "__algorithm/ranges_binary_search.h"
496      export std.functional.ranges_operations
497    }
498    module ranges_clamp {
499      header "__algorithm/ranges_clamp.h"
500      export std.functional.ranges_operations
501    }
502    module ranges_contains_subrange {
503      header "__algorithm/ranges_contains_subrange.h"
504    }
505    module ranges_contains {
506      header "__algorithm/ranges_contains.h"
507    }
508    module ranges_copy_backward {
509      header "__algorithm/ranges_copy_backward.h"
510      export std.algorithm.in_out_result
511    }
512    module ranges_copy_if {
513      header "__algorithm/ranges_copy_if.h"
514      export std.algorithm.in_out_result
515    }
516    module ranges_copy_n {
517      header "__algorithm/ranges_copy_n.h"
518      export std.algorithm.in_out_result
519    }
520    module ranges_copy {
521      header "__algorithm/ranges_copy.h"
522      export std.algorithm.in_out_result
523    }
524    module ranges_count_if                        { header "__algorithm/ranges_count_if.h" }
525    module ranges_count                           { header "__algorithm/ranges_count.h" }
526    module ranges_ends_with                       { header "__algorithm/ranges_ends_with.h" }
527    module ranges_equal_range {
528      header "__algorithm/ranges_equal_range.h"
529      export std.functional.ranges_operations
530    }
531    module ranges_equal {
532      header "__algorithm/ranges_equal.h"
533      export std.functional.identity
534    }
535    module ranges_fill_n                          { header "__algorithm/ranges_fill_n.h" }
536    module ranges_fill                            { header "__algorithm/ranges_fill.h" }
537    module ranges_find_end                        { header "__algorithm/ranges_find_end.h" }
538    module ranges_find_first_of                   { header "__algorithm/ranges_find_first_of.h" }
539    module ranges_find_if_not                     { header "__algorithm/ranges_find_if_not.h" }
540    module ranges_find_if                         { header "__algorithm/ranges_find_if.h" }
541    module ranges_find_last                       { header "__algorithm/ranges_find_last.h" }
542    module ranges_find                            { header "__algorithm/ranges_find.h" }
543    module ranges_fold                            { header "__algorithm/ranges_fold.h" }
544    module ranges_for_each_n {
545      header "__algorithm/ranges_for_each_n.h"
546      export std.algorithm.in_fun_result
547    }
548    module ranges_for_each {
549      header "__algorithm/ranges_for_each.h"
550      export std.algorithm.in_fun_result
551    }
552    module ranges_generate_n {
553      header "__algorithm/ranges_generate_n.h"
554    }
555    module ranges_generate {
556      header "__algorithm/ranges_generate.h"
557    }
558    module ranges_includes {
559      header "__algorithm/ranges_includes.h"
560      export std.functional.ranges_operations
561    }
562    module ranges_inplace_merge {
563      header "__algorithm/ranges_inplace_merge.h"
564      export std.functional.ranges_operations
565    }
566    module ranges_is_heap_until {
567      header "__algorithm/ranges_is_heap_until.h"
568      export std.functional.ranges_operations
569    }
570    module ranges_is_heap {
571      header "__algorithm/ranges_is_heap.h"
572      export std.functional.ranges_operations
573    }
574    module ranges_is_partitioned {
575      header "__algorithm/ranges_is_partitioned.h"
576    }
577    module ranges_is_permutation {
578      header "__algorithm/ranges_is_permutation.h"
579    }
580    module ranges_is_sorted_until {
581      header "__algorithm/ranges_is_sorted_until.h"
582      export std.functional.ranges_operations
583    }
584    module ranges_is_sorted {
585      header "__algorithm/ranges_is_sorted.h"
586      export std.functional.ranges_operations
587    }
588    module ranges_iterator_concept {
589      header "__algorithm/ranges_iterator_concept.h"
590    }
591    module ranges_lexicographical_compare {
592      header "__algorithm/ranges_lexicographical_compare.h"
593      export std.functional.ranges_operations
594    }
595    module ranges_lower_bound {
596      header "__algorithm/ranges_lower_bound.h"
597      export std.functional.ranges_operations
598    }
599    module ranges_make_heap {
600      header "__algorithm/ranges_make_heap.h"
601      export std.functional.ranges_operations
602    }
603    module ranges_max_element {
604      header "__algorithm/ranges_max_element.h"
605      export std.functional.ranges_operations
606    }
607    module ranges_max {
608      header "__algorithm/ranges_max.h"
609      export std.functional.ranges_operations
610    }
611    module ranges_merge {
612      header "__algorithm/ranges_merge.h"
613      export std.functional.ranges_operations
614      export std.algorithm.in_in_out_result
615    }
616    module ranges_min_element {
617      header "__algorithm/ranges_min_element.h"
618      export std.functional.ranges_operations
619    }
620    module ranges_min {
621      header "__algorithm/ranges_min.h"
622      export std.functional.ranges_operations
623    }
624    module ranges_minmax_element {
625      header "__algorithm/ranges_minmax_element.h"
626      export std.functional.ranges_operations
627      export std.algorithm.min_max_result
628    }
629    module ranges_minmax {
630      header "__algorithm/ranges_minmax.h"
631      export std.functional.ranges_operations
632      export std.algorithm.min_max_result
633    }
634    module ranges_mismatch {
635      header "__algorithm/ranges_mismatch.h"
636      export std.algorithm.in_in_result
637    }
638    module ranges_move_backward {
639      header "__algorithm/ranges_move_backward.h"
640      export std.algorithm.in_out_result
641    }
642    module ranges_move {
643      header "__algorithm/ranges_move.h"
644      export std.algorithm.in_out_result
645    }
646    module ranges_next_permutation {
647      header "__algorithm/ranges_next_permutation.h"
648      export std.functional.ranges_operations
649      export std.algorithm.in_found_result
650    }
651    module ranges_none_of {
652      header "__algorithm/ranges_none_of.h"
653    }
654    module ranges_nth_element {
655      header "__algorithm/ranges_nth_element.h"
656      export std.functional.ranges_operations
657    }
658    module ranges_partial_sort_copy {
659      header "__algorithm/ranges_partial_sort_copy.h"
660      export std.functional.ranges_operations
661    }
662    module ranges_partial_sort {
663      header "__algorithm/ranges_partial_sort.h"
664      export std.functional.ranges_operations
665    }
666    module ranges_partition_copy {
667      header "__algorithm/ranges_partition_copy.h"
668      export std.algorithm.in_out_out_result
669    }
670    module ranges_partition_point {
671      header "__algorithm/ranges_partition_point.h"
672    }
673    module ranges_partition {
674      header "__algorithm/ranges_partition.h"
675    }
676    module ranges_pop_heap {
677      header "__algorithm/ranges_pop_heap.h"
678      export std.functional.ranges_operations
679    }
680    module ranges_prev_permutation {
681      header "__algorithm/ranges_prev_permutation.h"
682      export std.functional.ranges_operations
683      export std.algorithm.in_found_result
684    }
685    module ranges_push_heap {
686      header "__algorithm/ranges_push_heap.h"
687      export std.functional.ranges_operations
688    }
689    module ranges_remove_copy_if {
690      header "__algorithm/ranges_remove_copy_if.h"
691      export std.algorithm.in_out_result
692    }
693    module ranges_remove_copy {
694      header "__algorithm/ranges_remove_copy.h"
695      export std.algorithm.in_out_result
696    }
697    module ranges_remove_if {
698      header "__algorithm/ranges_remove_if.h"
699    }
700    module ranges_remove {
701      header "__algorithm/ranges_remove.h"
702    }
703    module ranges_replace_copy_if {
704      header "__algorithm/ranges_replace_copy_if.h"
705      export std.algorithm.in_out_result
706    }
707    module ranges_replace_copy {
708      header "__algorithm/ranges_replace_copy.h"
709      export std.algorithm.in_out_result
710    }
711    module ranges_replace_if {
712      header "__algorithm/ranges_replace_if.h"
713    }
714    module ranges_replace {
715      header "__algorithm/ranges_replace.h"
716    }
717    module ranges_reverse_copy {
718      header "__algorithm/ranges_reverse_copy.h"
719      export std.algorithm.in_out_result
720    }
721    module ranges_reverse {
722      header "__algorithm/ranges_reverse.h"
723    }
724    module ranges_rotate_copy {
725      header "__algorithm/ranges_rotate_copy.h"
726      export std.algorithm.in_out_result
727    }
728    module ranges_rotate                          { header "__algorithm/ranges_rotate.h" }
729    module ranges_sample                          { header "__algorithm/ranges_sample.h" }
730    module ranges_search_n                        { header "__algorithm/ranges_search_n.h" }
731    module ranges_search                          { header "__algorithm/ranges_search.h" }
732    module ranges_set_difference {
733      header "__algorithm/ranges_set_difference.h"
734      export std.functional.ranges_operations
735      export std.algorithm.in_out_result
736    }
737    module ranges_set_intersection {
738      header "__algorithm/ranges_set_intersection.h"
739      export std.functional.ranges_operations
740      export std.algorithm.in_in_out_result
741    }
742    module ranges_set_symmetric_difference {
743      header "__algorithm/ranges_set_symmetric_difference.h"
744      export std.functional.ranges_operations
745      export std.algorithm.in_in_out_result
746    }
747    module ranges_set_union {
748      header "__algorithm/ranges_set_union.h"
749      export std.functional.ranges_operations
750      export std.algorithm.in_in_out_result
751    }
752    module ranges_shuffle {
753      header "__algorithm/ranges_shuffle.h"
754    }
755    module ranges_sort_heap {
756      header "__algorithm/ranges_sort_heap.h"
757      export std.functional.ranges_operations
758    }
759    module ranges_sort {
760      header "__algorithm/ranges_sort.h"
761      export std.functional.ranges_operations
762    }
763    module ranges_stable_partition {
764      header "__algorithm/ranges_stable_partition.h"
765    }
766    module ranges_stable_sort {
767      header "__algorithm/ranges_stable_sort.h"
768      export std.functional.ranges_operations
769    }
770    module ranges_starts_with {
771      header "__algorithm/ranges_starts_with.h"
772    }
773    module ranges_swap_ranges {
774      header "__algorithm/ranges_swap_ranges.h"
775      export std.algorithm.in_in_result
776    }
777    module ranges_transform {
778      header "__algorithm/ranges_transform.h"
779      export std.algorithm.in_out_result
780      export std.algorithm.in_in_out_result
781    }
782    module ranges_unique_copy {
783      header "__algorithm/ranges_unique_copy.h"
784    }
785    module ranges_unique {
786      header "__algorithm/ranges_unique.h"
787    }
788    module ranges_upper_bound {
789      header "__algorithm/ranges_upper_bound.h"
790      export std.functional.ranges_operations
791    }
792    module remove_copy_if                         { header "__algorithm/remove_copy_if.h" }
793    module remove_copy                            { header "__algorithm/remove_copy.h" }
794    module remove_if                              { header "__algorithm/remove_if.h" }
795    module remove                                 { header "__algorithm/remove.h" }
796    module replace_copy_if                        { header "__algorithm/replace_copy_if.h" }
797    module replace_copy                           { header "__algorithm/replace_copy.h" }
798    module replace_if                             { header "__algorithm/replace_if.h" }
799    module replace                                { header "__algorithm/replace.h" }
800    module reverse_copy                           { header "__algorithm/reverse_copy.h" }
801    module reverse                                { header "__algorithm/reverse.h" }
802    module rotate_copy                            { header "__algorithm/rotate_copy.h" }
803    module rotate                                 { header "__algorithm/rotate.h" }
804    module sample                                 { header "__algorithm/sample.h" }
805    module search_n                               { header "__algorithm/search_n.h" }
806    module search                                 { header "__algorithm/search.h" }
807    module set_difference                         { header "__algorithm/set_difference.h" }
808    module set_intersection                       { header "__algorithm/set_intersection.h" }
809    module set_symmetric_difference               { header "__algorithm/set_symmetric_difference.h" }
810    module set_union                              { header "__algorithm/set_union.h" }
811    module shift_left                             { header "__algorithm/shift_left.h" }
812    module shift_right                            { header "__algorithm/shift_right.h" }
813    module shuffle                                { header "__algorithm/shuffle.h" }
814    module sift_down                              { header "__algorithm/sift_down.h" }
815    module simd_utils                             { header "__algorithm/simd_utils.h" }
816    module sort_heap                              { header "__algorithm/sort_heap.h" }
817    module sort                                   { header "__algorithm/sort.h" }
818    module stable_partition                       { header "__algorithm/stable_partition.h" }
819    module stable_sort                            { header "__algorithm/stable_sort.h" }
820    module swap_ranges                            { header "__algorithm/swap_ranges.h" }
821    module three_way_comp_ref_type                { header "__algorithm/three_way_comp_ref_type.h" }
822    module transform                              { header "__algorithm/transform.h" }
823    module uniform_random_bit_generator_adaptor   { header "__algorithm/uniform_random_bit_generator_adaptor.h" }
824    module unique_copy                            { header "__algorithm/unique_copy.h" }
825    module unique                                 { header "__algorithm/unique.h" }
826    module unwrap_iter                            { header "__algorithm/unwrap_iter.h" }
827    module unwrap_range                           { header "__algorithm/unwrap_range.h" }
828    module upper_bound                            { header "__algorithm/upper_bound.h" }
829
830    header "algorithm"
831    export *
832  } // module algorithm
833
834  module any {
835    header "any"
836    export *
837  }
838
839  module array {
840    module fwd { header "__fwd/array.h" }
841
842    header "array"
843    export *
844  }
845
846  module atomic {
847    module aliases                { header "__atomic/aliases.h" }
848    module atomic_flag            { header "__atomic/atomic_flag.h" }
849    module atomic_init            { header "__atomic/atomic_init.h" }
850    module atomic_lock_free       { header "__atomic/atomic_lock_free.h" }
851    module atomic_ref             { header "__atomic/atomic_ref.h" }
852    module atomic_sync            { header "__atomic/atomic_sync.h" }
853    module atomic {
854      header "__atomic/atomic.h"
855      export std.atomic.atomic_base // most of std::atomic methods are defined there
856    }
857    module check_memory_order     { header "__atomic/check_memory_order.h" }
858    module contention_t           { header "__atomic/contention_t.h" }
859    module cxx_atomic_impl        { header "__atomic/cxx_atomic_impl.h" }
860    module fence                  { header "__atomic/fence.h" }
861    module is_always_lock_free    { header "__atomic/is_always_lock_free.h" }
862    module kill_dependency        { header "__atomic/kill_dependency.h" }
863    module memory_order           { header "__atomic/memory_order.h" }
864    module to_gcc_order           { header "__atomic/to_gcc_order.h" }
865
866    header "atomic"
867    export *
868  }
869
870  module barrier {
871    header "barrier"
872    export *
873  }
874
875  module bit {
876    module bit_cast         { header "__bit/bit_cast.h" }
877    module bit_ceil         { header "__bit/bit_ceil.h" }
878    module bit_floor        { header "__bit/bit_floor.h" }
879    module bit_log2         { header "__bit/bit_log2.h" }
880    module bit_width        { header "__bit/bit_width.h" }
881    module blsr             { header "__bit/blsr.h" }
882    module byteswap         { header "__bit/byteswap.h" }
883    module countl           { header "__bit/countl.h" }
884    module countr           { header "__bit/countr.h" }
885    module endian           { header "__bit/endian.h" }
886    module has_single_bit   { header "__bit/has_single_bit.h" }
887    module invert_if        { header "__bit/invert_if.h" }
888    module popcount         { header "__bit/popcount.h" }
889    module rotate           { header "__bit/rotate.h" }
890
891    header "bit"
892    export *
893  }
894
895  module bitset {
896    header "bitset"
897    export *
898  }
899
900  module charconv {
901    module chars_format               { header "__charconv/chars_format.h" }
902    module from_chars_floating_point  { header "__charconv/from_chars_floating_point.h" }
903    module from_chars_integral        { header "__charconv/from_chars_integral.h" }
904    module from_chars_result          { header "__charconv/from_chars_result.h" }
905    module tables                     { header "__charconv/tables.h" }
906    module to_chars                   { header "__charconv/to_chars.h" }
907    module to_chars_base_10           { header "__charconv/to_chars_base_10.h" }
908    module to_chars_floating_point    { header "__charconv/to_chars_floating_point.h" }
909    module to_chars_integral          { header "__charconv/to_chars_integral.h" }
910    module to_chars_result            { header "__charconv/to_chars_result.h" }
911    module traits                     { header "__charconv/traits.h" }
912
913    header "charconv"
914    export *
915  }
916
917  module chrono {
918    module calendar                   { header "__chrono/calendar.h" }
919    module concepts                   { header "__chrono/concepts.h" }
920    module convert_to_timespec        { header "__chrono/convert_to_timespec.h" }
921    module convert_to_tm              { header "__chrono/convert_to_tm.h" }
922    module day                        { header "__chrono/day.h" }
923    module duration                   { header "__chrono/duration.h" }
924    module exception                  { header "__chrono/exception.h" }
925    module file_clock                 { header "__chrono/file_clock.h" }
926    module formatter                  { header "__chrono/formatter.h" }
927    module hh_mm_ss                   { header "__chrono/hh_mm_ss.h" }
928    module high_resolution_clock {
929      header "__chrono/high_resolution_clock.h"
930      export *
931    }
932    module leap_second {
933      header "__chrono/leap_second.h"
934    }
935    module literals {
936      header "__chrono/literals.h"
937    }
938    module local_info {
939      header "__chrono/local_info.h"
940      export std.chrono.sys_info
941    }
942    module month_weekday              { header "__chrono/month_weekday.h" }
943    module month                      { header "__chrono/month.h" }
944    module monthday                   { header "__chrono/monthday.h" }
945    module ostream                    { header "__chrono/ostream.h" }
946    module parser_std_format_spec     { header "__chrono/parser_std_format_spec.h" }
947    module statically_widen           { header "__chrono/statically_widen.h" }
948    module steady_clock {
949      header "__chrono/steady_clock.h"
950      export std.chrono.time_point
951    }
952    module sys_info {
953      header "__chrono/sys_info.h"
954    }
955    module system_clock {
956      header "__chrono/system_clock.h"
957      export std.chrono.time_point
958    }
959    module time_point                 { header "__chrono/time_point.h" }
960    module time_zone_link             { header "__chrono/time_zone_link.h" }
961    module time_zone                  { header "__chrono/time_zone.h" }
962    module tzdb_list {
963      header "__chrono/tzdb_list.h"
964      export std.forward_list // forward_list iterators are used to implement this API
965      export std.string_view // by-value argument of type std::string_view
966    }
967    module tzdb {
968      header "__chrono/tzdb.h"
969      export std.string // public data member of type std::string
970      export std.vector // public data members of type std::vector
971    }
972    module weekday                    { header "__chrono/weekday.h" }
973    module year_month_day             { header "__chrono/year_month_day.h" }
974    module year_month_weekday         { header "__chrono/year_month_weekday.h" }
975    module year_month                 { header "__chrono/year_month.h" }
976    module year                       { header "__chrono/year.h" }
977    module zoned_time                 { header "__chrono/zoned_time.h" }
978
979    header "chrono"
980    export *
981  } // module chrono
982
983  module codecvt {
984    header "codecvt"
985    export *
986  }
987
988  module compare {
989    module common_comparison_category       { header "__compare/common_comparison_category.h" }
990    module compare_partial_order_fallback   { header "__compare/compare_partial_order_fallback.h" }
991    module compare_strong_order_fallback    { header "__compare/compare_strong_order_fallback.h" }
992    module compare_three_way                { header "__compare/compare_three_way.h" }
993    module compare_three_way_result         { header "__compare/compare_three_way_result.h" }
994    module compare_weak_order_fallback      { header "__compare/compare_weak_order_fallback.h" }
995    module is_eq                            { header "__compare/is_eq.h" }
996    module ordering                         { header "__compare/ordering.h" }
997    module partial_order                    { header "__compare/partial_order.h" }
998    module strong_order                     { header "__compare/strong_order.h" }
999    module synth_three_way                  { header "__compare/synth_three_way.h" }
1000    module three_way_comparable             { header "__compare/three_way_comparable.h" }
1001    module weak_order                       { header "__compare/weak_order.h" }
1002
1003    header "compare"
1004    export *
1005  }
1006
1007  module complex {
1008    module fwd { header "__fwd/complex.h" }
1009
1010    header "complex"
1011    export *
1012  }
1013
1014  module concepts {
1015    module arithmetic               { header "__concepts/arithmetic.h" }
1016    module assignable               { header "__concepts/assignable.h" }
1017    module boolean_testable         { header "__concepts/boolean_testable.h" }
1018    module class_or_enum            { header "__concepts/class_or_enum.h" }
1019    module common_reference_with    { header "__concepts/common_reference_with.h" }
1020    module common_with              { header "__concepts/common_with.h" }
1021    module constructible            { header "__concepts/constructible.h" }
1022    module convertible_to           { header "__concepts/convertible_to.h" }
1023    module copyable                 { header "__concepts/copyable.h" }
1024    module derived_from             { header "__concepts/derived_from.h" }
1025    module destructible             { header "__concepts/destructible.h" }
1026    module different_from           { header "__concepts/different_from.h" }
1027    module equality_comparable      { header "__concepts/equality_comparable.h" }
1028    module invocable                { header "__concepts/invocable.h" }
1029    module movable                  { header "__concepts/movable.h" }
1030    module predicate                { header "__concepts/predicate.h" }
1031    module regular                  { header "__concepts/regular.h" }
1032    module relation                 { header "__concepts/relation.h" }
1033    module same_as                  { header "__concepts/same_as.h" }
1034    module semiregular              { header "__concepts/semiregular.h" }
1035    module swappable                { header "__concepts/swappable.h" }
1036    module totally_ordered          { header "__concepts/totally_ordered.h" }
1037
1038    header "concepts"
1039    export *
1040  }
1041
1042  module condition_variable {
1043    module condition_variable   { header "__condition_variable/condition_variable.h" }
1044
1045    header "condition_variable"
1046    export *
1047  }
1048
1049  module cassert {
1050    textual header "cassert" // NDEBUG requires textual inclusion
1051  }
1052
1053  module ccomplex {
1054    header "ccomplex"
1055    export *
1056  }
1057
1058  module cctype {
1059    header "cctype"
1060    export *
1061  }
1062
1063  module cerrno {
1064    header "cerrno"
1065    export *
1066  }
1067
1068  module cfenv {
1069    header "cfenv"
1070    export *
1071  }
1072
1073  module cfloat {
1074    header "cfloat"
1075    export *
1076  }
1077
1078  module cinttypes {
1079    header "cinttypes"
1080    export *
1081  }
1082
1083  module ciso646 {
1084    header "ciso646"
1085    export *
1086  }
1087
1088  module climits {
1089    header "climits"
1090    export *
1091  }
1092
1093  module clocale {
1094    header "clocale"
1095    export *
1096  }
1097
1098  module cmath {
1099    header "cmath"
1100    export *
1101  }
1102
1103  // TODO: Make non-textual. This seems to cause problems when compiling against Glibc.
1104  module csetjmp {
1105    textual header "csetjmp"
1106  }
1107
1108  module csignal {
1109    header "csignal"
1110    export *
1111  }
1112
1113  module cstdalign {
1114    header "cstdalign"
1115    export *
1116  }
1117
1118  module cstdarg {
1119    header "cstdarg"
1120    export *
1121  }
1122
1123  module cstdbool {
1124    header "cstdbool"
1125    export *
1126  }
1127
1128  module cstddef {
1129    header "cstddef"
1130    export *
1131  }
1132
1133  module cstdio {
1134    header "cstdio"
1135    export *
1136  }
1137
1138  module cstdlib {
1139    header "cstdlib"
1140    export *
1141  }
1142
1143  module cstring {
1144    header "cstring"
1145    export *
1146  }
1147
1148  module ctgmath {
1149    header "ctgmath"
1150    export *
1151  }
1152
1153  module ctime {
1154    header "ctime"
1155    export *
1156  }
1157
1158  module cuchar {
1159    header "cuchar"
1160    export *
1161  }
1162
1163  module cwchar {
1164    header "cwchar"
1165    export *
1166  }
1167
1168  module cwctype {
1169    header "cwctype"
1170    export *
1171  }
1172
1173  module deque {
1174    module fwd { header "__fwd/deque.h" }
1175
1176    header "deque"
1177    export *
1178  }
1179
1180  module exception {
1181    module exception          { header "__exception/exception.h" }
1182    module exception_ptr      { header "__exception/exception_ptr.h" }
1183    module nested_exception   { header "__exception/nested_exception.h" }
1184    module operations         { header "__exception/operations.h" }
1185    module terminate          { header "__exception/terminate.h" }
1186
1187    header "exception"
1188    export *
1189  }
1190
1191  module execution {
1192    header "execution"
1193    export *
1194  }
1195
1196  module expected {
1197    module bad_expected_access    { header "__expected/bad_expected_access.h" }
1198    module expected               { header "__expected/expected.h" }
1199    module unexpect               { header "__expected/unexpect.h" }
1200    module unexpected             { header "__expected/unexpected.h" }
1201
1202    header "expected"
1203    export *
1204  }
1205
1206  module filesystem {
1207    module copy_options                   { header "__filesystem/copy_options.h" }
1208    module directory_entry                { header "__filesystem/directory_entry.h" }
1209    module directory_iterator             { header "__filesystem/directory_iterator.h" }
1210    module directory_options              { header "__filesystem/directory_options.h" }
1211    module file_status                    { header "__filesystem/file_status.h" }
1212    module file_time_type                 { header "__filesystem/file_time_type.h" }
1213    module file_type                      { header "__filesystem/file_type.h" }
1214    module filesystem_error               { header "__filesystem/filesystem_error.h" }
1215    module operations                     { header "__filesystem/operations.h" }
1216    module path_iterator                  { header "__filesystem/path_iterator.h" }
1217    module path                           {
1218      header "__filesystem/path.h"
1219      export std.string // returned by various methods of filesystem::path
1220    }
1221    module perm_options                   { header "__filesystem/perm_options.h" }
1222    module perms                          { header "__filesystem/perms.h" }
1223    module recursive_directory_iterator   { header "__filesystem/recursive_directory_iterator.h" }
1224    module space_info                     { header "__filesystem/space_info.h" }
1225    module u8path                         { header "__filesystem/u8path.h" }
1226
1227    header "filesystem"
1228    export *
1229  }
1230
1231  module flat_map {
1232    module flat_map                       { header "__flat_map/flat_map.h" }
1233    module sorted_unique                  { header "__flat_map/sorted_unique.h" }
1234
1235    header "flat_map"
1236    export *
1237  }
1238
1239  module format {
1240    module buffer                             { header "__format/buffer.h" }
1241    module concepts                           { header "__format/concepts.h" }
1242    module container_adaptor                  { header "__format/container_adaptor.h" }
1243    module enable_insertable                  { header "__format/enable_insertable.h" }
1244    module escaped_output_table               { header "__format/escaped_output_table.h" }
1245    module extended_grapheme_cluster_table    { header "__format/extended_grapheme_cluster_table.h" }
1246    module format_arg                         { header "__format/format_arg.h" }
1247    module format_arg_store                   { header "__format/format_arg_store.h" }
1248    module format_args                        { header "__format/format_args.h" }
1249    module format_context {
1250      header "__format/format_context.h"
1251      export std.optional // default argument for __format_context_create
1252    }
1253    module format_error {
1254      header "__format/format_error.h"
1255    }
1256    module format_functions {
1257      header "__format/format_functions.h"
1258      export std.string // returned by the functions in that header
1259    }
1260    module format_parse_context               { header "__format/format_parse_context.h" }
1261    module format_string                      { header "__format/format_string.h" }
1262    module format_to_n_result                 { header "__format/format_to_n_result.h" }
1263    module formatter                          { header "__format/formatter.h" }
1264    module formatter_bool                     { header "__format/formatter_bool.h" }
1265    module formatter_char                     { header "__format/formatter_char.h" }
1266    module formatter_floating_point           { header "__format/formatter_floating_point.h" }
1267    module formatter_integer                  { header "__format/formatter_integer.h" }
1268    module formatter_integral                 { header "__format/formatter_integral.h" }
1269    module formatter_output                   { header "__format/formatter_output.h" }
1270    module formatter_pointer                  { header "__format/formatter_pointer.h" }
1271    module formatter_string                   { header "__format/formatter_string.h" }
1272    module formatter_tuple                    { header "__format/formatter_tuple.h" }
1273    module fwd                                { header "__fwd/format.h" }
1274    module indic_conjunct_break_table         { header "__format/indic_conjunct_break_table.h" }
1275    module parser_std_format_spec             { header "__format/parser_std_format_spec.h" }
1276    module range_default_formatter            { header "__format/range_default_formatter.h" }
1277    module range_formatter                    { header "__format/range_formatter.h" }
1278    module unicode                            { header "__format/unicode.h" }
1279    module width_estimation_table             { header "__format/width_estimation_table.h" }
1280    module write_escaped                      { header "__format/write_escaped.h" }
1281
1282    header "format"
1283    export *
1284  } // module format
1285
1286  module forward_list {
1287    header "forward_list"
1288    export *
1289  }
1290
1291  module fstream {
1292    module fwd { header "__fwd/fstream.h" }
1293
1294    header "fstream"
1295    export *
1296  }
1297
1298  module functional {
1299    module binary_function              { header "__functional/binary_function.h" }
1300    module binary_negate                { header "__functional/binary_negate.h" }
1301    module bind_back {
1302      header "__functional/bind_back.h"
1303      export std.functional.perfect_forward // inherited from and using its operators
1304    }
1305    module bind_front {
1306      header "__functional/bind_front.h"
1307      export std.functional.perfect_forward // inherited from and using its operators
1308    }
1309    module bind                         { header "__functional/bind.h" }
1310    module binder1st                    { header "__functional/binder1st.h" }
1311    module binder2nd                    { header "__functional/binder2nd.h" }
1312    module boyer_moore_searcher {
1313      header "__functional/boyer_moore_searcher.h"
1314      export std.memory.shared_ptr
1315    }
1316    module compose {
1317      header "__functional/compose.h"
1318      export std.functional.perfect_forward // inherited from and using its operators
1319    }
1320    module default_searcher             { header "__functional/default_searcher.h" }
1321    module function                     { header "__functional/function.h" }
1322    module hash                         { header "__functional/hash.h" }
1323    module identity                     { header "__functional/identity.h" }
1324    module invoke                       { header "__functional/invoke.h" }
1325    module is_transparent               { header "__functional/is_transparent.h" }
1326    module mem_fn                       { header "__functional/mem_fn.h" }
1327    module mem_fun_ref                  { header "__functional/mem_fun_ref.h" }
1328    module not_fn {
1329      header "__functional/not_fn.h"
1330      export std.functional.perfect_forward // inherited from and using its operators
1331    }
1332    module operations                   { header "__functional/operations.h" }
1333    module perfect_forward {
1334      header "__functional/perfect_forward.h"
1335      export std.tuple
1336    }
1337    module pointer_to_binary_function   { header "__functional/pointer_to_binary_function.h" }
1338    module pointer_to_unary_function    { header "__functional/pointer_to_unary_function.h" }
1339    module ranges_operations            { header "__functional/ranges_operations.h" }
1340    module reference_wrapper            { header "__functional/reference_wrapper.h" }
1341    module unary_function               { header "__functional/unary_function.h" }
1342    module unary_negate                 { header "__functional/unary_negate.h" }
1343    module weak_result_type             { header "__functional/weak_result_type.h" }
1344
1345    header "functional"
1346    export *
1347  } // module functional
1348
1349  module future {
1350    header "future"
1351    export *
1352  }
1353
1354  module initializer_list {
1355    header "initializer_list"
1356    export *
1357  }
1358
1359  module iomanip {
1360    header "iomanip"
1361    export *
1362  }
1363
1364  module ios {
1365    module fwd  { header "__fwd/ios.h" }
1366    module fpos { header "__ios/fpos.h" }
1367
1368    header "ios"
1369    export *
1370  }
1371
1372  module iosfwd {
1373    header "iosfwd"
1374    export *
1375  }
1376
1377  module iostream {
1378    header "iostream"
1379    export *
1380  }
1381
1382  module istream {
1383    module fwd { header "__fwd/istream.h" }
1384
1385    header "istream"
1386    export std.ios // base class
1387  }
1388
1389  module iterator {
1390    module access                     { header "__iterator/access.h" }
1391    module advance                    { header "__iterator/advance.h" }
1392    module aliasing_iterator          { header "__iterator/aliasing_iterator.h" }
1393    module back_insert_iterator       { header "__iterator/back_insert_iterator.h" }
1394    module bounded_iter               { header "__iterator/bounded_iter.h" }
1395    module common_iterator            { header "__iterator/common_iterator.h" }
1396    module concepts {
1397      header "__iterator/concepts.h"
1398      export std_core.type_traits.common_reference
1399    }
1400    module counted_iterator           { header "__iterator/counted_iterator.h" }
1401    module cpp17_iterator_concepts    { header "__iterator/cpp17_iterator_concepts.h" }
1402    module data                       { header "__iterator/data.h" }
1403    module default_sentinel           { header "__iterator/default_sentinel.h" }
1404    module distance                   { header "__iterator/distance.h" }
1405    module empty                      { header "__iterator/empty.h" }
1406    module erase_if_container         { header "__iterator/erase_if_container.h" }
1407    module front_insert_iterator      { header "__iterator/front_insert_iterator.h" }
1408    module incrementable_traits       { header "__iterator/incrementable_traits.h" }
1409    module indirectly_comparable      { header "__iterator/indirectly_comparable.h" }
1410    module insert_iterator            { header "__iterator/insert_iterator.h" }
1411    module istream_iterator           { header "__iterator/istream_iterator.h" }
1412    module istreambuf_iterator        {
1413      header "__iterator/istreambuf_iterator.h"
1414      export std.string.char_traits
1415    }
1416    module iter_move                  { header "__iterator/iter_move.h" }
1417    module iter_swap                  { header "__iterator/iter_swap.h" }
1418    module iterator_traits {
1419      header "__iterator/iterator_traits.h"
1420      export std_core.type_traits.integral_constant
1421    }
1422    module iterator_with_data         { header "__iterator/iterator_with_data.h" }
1423    module iterator                   { header "__iterator/iterator.h" }
1424    module mergeable                  { header "__iterator/mergeable.h" }
1425    module move_iterator              { header "__iterator/move_iterator.h" }
1426    module move_sentinel              { header "__iterator/move_sentinel.h" }
1427    module next                       { header "__iterator/next.h" }
1428    module ostream_iterator           { header "__iterator/ostream_iterator.h" }
1429    module ostreambuf_iterator {
1430      header "__iterator/ostreambuf_iterator.h"
1431      export iosfwd // for default template argument of ostreambuf_iterator
1432    }
1433    module permutable                 { header "__iterator/permutable.h" }
1434    module prev                       { header "__iterator/prev.h" }
1435    module projected                  { header "__iterator/projected.h" }
1436    module ranges_iterator_traits     { header "__iterator/ranges_iterator_traits.h" }
1437    module readable_traits            { header "__iterator/readable_traits.h" }
1438    module reverse_access             { header "__iterator/reverse_access.h" }
1439    module reverse_iterator           { header "__iterator/reverse_iterator.h" }
1440    module segmented_iterator         { header "__iterator/segmented_iterator.h" }
1441    module size                       { header "__iterator/size.h" }
1442    module sortable                   { header "__iterator/sortable.h" }
1443    module static_bounded_iter        { header "__iterator/static_bounded_iter.h" }
1444    module unreachable_sentinel       { header "__iterator/unreachable_sentinel.h" }
1445    module wrap_iter                  { header "__iterator/wrap_iter.h" }
1446
1447    header "iterator"
1448    export *
1449  }
1450
1451  module latch {
1452    header "latch"
1453    export *
1454  }
1455
1456  module list {
1457    header "list"
1458    export *
1459  }
1460
1461  module locale {
1462    header "locale"
1463
1464    module locale_guard   { header "__locale_dir/locale_guard.h" }
1465    module pad_and_output { header "__locale_dir/pad_and_output.h" }
1466
1467    module support {
1468      header "__locale_dir/locale_base_api.h"
1469      export *
1470    }
1471
1472    module support_impl {
1473      textual header "__locale_dir/support/apple.h"
1474      textual header "__locale_dir/support/bsd_like.h"
1475      textual header "__locale_dir/support/freebsd.h"
1476    }
1477
1478    module locale_base_api {
1479      textual header "__locale_dir/locale_base_api/android.h"
1480      textual header "__locale_dir/locale_base_api/bsd_locale_defaults.h"
1481      textual header "__locale_dir/locale_base_api/bsd_locale_fallbacks.h"
1482      textual header "__locale_dir/locale_base_api/fuchsia.h"
1483      textual header "__locale_dir/locale_base_api/ibm.h"
1484      textual header "__locale_dir/locale_base_api/musl.h"
1485      textual header "__locale_dir/locale_base_api/openbsd.h"
1486      textual header "__locale_dir/locale_base_api/win32.h"
1487    }
1488    export *
1489  }
1490
1491  // TODO: Understand why this needs to live in its own module
1492  module locale_base [system] {
1493    header "__locale"
1494    export *
1495  }
1496
1497  module map {
1498    header "map"
1499    export *
1500  }
1501
1502  module mdspan {
1503    module default_accessor   { header "__mdspan/default_accessor.h" }
1504    module extents            { header "__mdspan/extents.h" }
1505    module fwd                { header "__fwd/mdspan.h" }
1506    module layout_left        { header "__mdspan/layout_left.h" }
1507    module layout_right       { header "__mdspan/layout_right.h" }
1508    module layout_stride      { header "__mdspan/layout_stride.h" }
1509    module mdspan {
1510      header "__mdspan/mdspan.h"
1511      export std.array // returned by some methods
1512    }
1513
1514    header "mdspan"
1515    export *
1516  }
1517
1518  module memory {
1519    module addressof                          { header "__memory/addressof.h" }
1520    module align                              { header "__memory/align.h" }
1521    module aligned_alloc                      { header "__memory/aligned_alloc.h" }
1522    module allocate_at_least                  { header "__memory/allocate_at_least.h" }
1523    module allocation_guard                   { header "__memory/allocation_guard.h" }
1524    module allocator                          { header "__memory/allocator.h" }
1525    module allocator_arg_t                    { header "__memory/allocator_arg_t.h" }
1526    module allocator_destructor               { header "__memory/allocator_destructor.h" }
1527    module allocator_traits                   { header "__memory/allocator_traits.h" }
1528    module array_cookie                       { header "__memory/array_cookie.h" }
1529    module assume_aligned                     { header "__memory/assume_aligned.h" }
1530    module auto_ptr                           { header "__memory/auto_ptr.h" }
1531    module builtin_new_allocator              { header "__memory/builtin_new_allocator.h" }
1532    module compressed_pair                    { header "__memory/compressed_pair.h" }
1533    module concepts                           { header "__memory/concepts.h" }
1534    module construct_at                       { header "__memory/construct_at.h" }
1535    module destruct_n                         { header "__memory/destruct_n.h" }
1536    module fwd                                { header "__fwd/memory.h" }
1537    module inout_ptr                          { header "__memory/inout_ptr.h" }
1538    module noexcept_move_assign_container     { header "__memory/noexcept_move_assign_container.h" }
1539    module out_ptr                            { header "__memory/out_ptr.h" }
1540    module pointer_traits                     { header "__memory/pointer_traits.h" }
1541    module ranges_construct_at                { header "__memory/ranges_construct_at.h" }
1542    module ranges_uninitialized_algorithms {
1543      header "__memory/ranges_uninitialized_algorithms.h"
1544      export std.algorithm.in_out_result
1545    }
1546    module raw_storage_iterator               { header "__memory/raw_storage_iterator.h" }
1547    module shared_count                       { header "__memory/shared_count.h" }
1548    module shared_ptr                         { header "__memory/shared_ptr.h" }
1549    module swap_allocator                     { header "__memory/swap_allocator.h" }
1550    module temp_value                         { header "__memory/temp_value.h" }
1551    module temporary_buffer                   {
1552      header "__memory/temporary_buffer.h"
1553      export std.utility.pair // return type of std::get_temporary_buffer()
1554    }
1555    module uninitialized_algorithms {
1556      header "__memory/uninitialized_algorithms.h"
1557      export std.utility.pair
1558    }
1559    module unique_ptr {
1560      header "__memory/unique_ptr.h"
1561    }
1562    module unique_temporary_buffer {
1563      header "__memory/unique_temporary_buffer.h"
1564      export std.memory.unique_ptr
1565      export std_core.type_traits.is_constant_evaluated
1566    }
1567    module uses_allocator                     { header "__memory/uses_allocator.h" }
1568    module uses_allocator_construction        { header "__memory/uses_allocator_construction.h" }
1569
1570    header "memory"
1571    export *
1572  }
1573
1574  module memory_resource {
1575    module fwd                            { header "__fwd/memory_resource.h" }
1576    module memory_resource                { header "__memory_resource/memory_resource.h" }
1577    module monotonic_buffer_resource      { header "__memory_resource/monotonic_buffer_resource.h" }
1578    module polymorphic_allocator          { header "__memory_resource/polymorphic_allocator.h" }
1579    module pool_options                   { header "__memory_resource/pool_options.h" }
1580    module synchronized_pool_resource     { header "__memory_resource/synchronized_pool_resource.h" }
1581    module unsynchronized_pool_resource   { header "__memory_resource/unsynchronized_pool_resource.h" }
1582
1583    header "memory_resource"
1584    export *
1585  }
1586
1587  module mutex {
1588    module lock_guard     { header "__mutex/lock_guard.h" }
1589    module mutex          { header "__mutex/mutex.h" }
1590    module once_flag      { header "__mutex/once_flag.h" }
1591    module tag_types      { header "__mutex/tag_types.h" }
1592    module unique_lock    { header "__mutex/unique_lock.h" }
1593
1594    header "mutex"
1595    export *
1596  }
1597
1598  module new {
1599    header "new"
1600    export *
1601  }
1602
1603  module numbers {
1604    header "numbers"
1605    export *
1606  }
1607
1608  module numeric {
1609    module accumulate                 { header "__numeric/accumulate.h" }
1610    module adjacent_difference        { header "__numeric/adjacent_difference.h" }
1611    module exclusive_scan             { header "__numeric/exclusive_scan.h" }
1612    module gcd_lcm                    { header "__numeric/gcd_lcm.h" }
1613    module inclusive_scan             { header "__numeric/inclusive_scan.h" }
1614    module inner_product              { header "__numeric/inner_product.h" }
1615    module iota                       { header "__numeric/iota.h" }
1616    module midpoint                   { header "__numeric/midpoint.h" }
1617    module partial_sum                { header "__numeric/partial_sum.h" }
1618    module pstl                       { header "__numeric/pstl.h" }
1619    module reduce                     { header "__numeric/reduce.h" }
1620    module saturation_arithmetic      { header "__numeric/saturation_arithmetic.h" }
1621    module transform_exclusive_scan   { header "__numeric/transform_exclusive_scan.h" }
1622    module transform_inclusive_scan   { header "__numeric/transform_inclusive_scan.h" }
1623    module transform_reduce           { header "__numeric/transform_reduce.h" }
1624
1625    header "numeric"
1626    export *
1627  }
1628
1629  module optional {
1630    header "optional"
1631    export *
1632  }
1633
1634  module ostream {
1635    module basic_ostream {
1636      header "__ostream/basic_ostream.h"
1637      export std.ios // base class
1638    }
1639    module fwd {
1640      header "__fwd/ostream.h"
1641    }
1642    module print {
1643      header "__ostream/print.h"
1644      export *
1645    }
1646    module put_character_sequence { header "__ostream/put_character_sequence.h" }
1647
1648    header "ostream"
1649    export *
1650  }
1651
1652  module print {
1653    header "print"
1654    export *
1655  }
1656
1657  module queue {
1658    module fwd { header "__fwd/queue.h" }
1659
1660    header "queue"
1661    export *
1662  }
1663
1664  module random {
1665    module bernoulli_distribution             { header "__random/bernoulli_distribution.h" }
1666    module binomial_distribution              { header "__random/binomial_distribution.h" }
1667    module cauchy_distribution                { header "__random/cauchy_distribution.h" }
1668    module chi_squared_distribution           { header "__random/chi_squared_distribution.h" }
1669    module clamp_to_integral                  { header "__random/clamp_to_integral.h" }
1670    module default_random_engine              { header "__random/default_random_engine.h" }
1671    module discard_block_engine               { header "__random/discard_block_engine.h" }
1672    module discrete_distribution              { header "__random/discrete_distribution.h" }
1673    module exponential_distribution           { header "__random/exponential_distribution.h" }
1674    module extreme_value_distribution         { header "__random/extreme_value_distribution.h" }
1675    module fisher_f_distribution              { header "__random/fisher_f_distribution.h" }
1676    module gamma_distribution                 { header "__random/gamma_distribution.h" }
1677    module generate_canonical                 { header "__random/generate_canonical.h" }
1678    module geometric_distribution             { header "__random/geometric_distribution.h" }
1679    module independent_bits_engine            { header "__random/independent_bits_engine.h" }
1680    module is_seed_sequence                   { header "__random/is_seed_sequence.h" }
1681    module is_valid {
1682      header "__random/is_valid.h"
1683      export std_core.type_traits.integral_constant
1684    }
1685    module knuth_b                            { header "__random/knuth_b.h" }
1686    module linear_congruential_engine         { header "__random/linear_congruential_engine.h" }
1687    module log2                               { header "__random/log2.h" }
1688    module lognormal_distribution             { header "__random/lognormal_distribution.h" }
1689    module mersenne_twister_engine            { header "__random/mersenne_twister_engine.h" }
1690    module negative_binomial_distribution     { header "__random/negative_binomial_distribution.h" }
1691    module normal_distribution                { header "__random/normal_distribution.h" }
1692    module piecewise_constant_distribution    { header "__random/piecewise_constant_distribution.h" }
1693    module piecewise_linear_distribution      { header "__random/piecewise_linear_distribution.h" }
1694    module poisson_distribution               { header "__random/poisson_distribution.h" }
1695    module random_device                      { header "__random/random_device.h" }
1696    module ranlux                             { header "__random/ranlux.h" }
1697    module seed_seq                           { header "__random/seed_seq.h" }
1698    module shuffle_order_engine               { header "__random/shuffle_order_engine.h" }
1699    module student_t_distribution             { header "__random/student_t_distribution.h" }
1700    module subtract_with_carry_engine         { header "__random/subtract_with_carry_engine.h" }
1701    module uniform_int_distribution           { header "__random/uniform_int_distribution.h" }
1702    module uniform_random_bit_generator       { header "__random/uniform_random_bit_generator.h" }
1703    module uniform_real_distribution          { header "__random/uniform_real_distribution.h" }
1704    module weibull_distribution               { header "__random/weibull_distribution.h" }
1705
1706    header "random"
1707    export *
1708  }
1709
1710  module ranges {
1711    module access                         { header "__ranges/access.h" }
1712    module all                            { header "__ranges/all.h" }
1713    module as_rvalue_view                 { header "__ranges/as_rvalue_view.h" }
1714    module chunk_by_view {
1715      header "__ranges/chunk_by_view.h"
1716      export std.functional.bind_back
1717    }
1718    module common_view                    { header "__ranges/common_view.h" }
1719    module concepts                       { header "__ranges/concepts.h" }
1720    module container_compatible_range     { header "__ranges/container_compatible_range.h" }
1721    module counted {
1722      header "__ranges/counted.h"
1723      export std.span            // return type of views::counted
1724      export std.ranges.subrange // return type of views::counted
1725    }
1726    module dangling {
1727      header "__ranges/dangling.h"
1728    }
1729    module data {
1730      header "__ranges/data.h"
1731    }
1732    module drop_view {
1733      header "__ranges/drop_view.h"
1734      export std.functional.bind_back
1735    }
1736    module drop_while_view {
1737      header "__ranges/drop_while_view.h"
1738      export std.functional.bind_back
1739    }
1740    module elements_view                  { header "__ranges/elements_view.h" }
1741    module empty                          { header "__ranges/empty.h" }
1742    module empty_view                     { header "__ranges/empty_view.h" }
1743    module enable_borrowed_range          { header "__ranges/enable_borrowed_range.h" }
1744    module enable_view                    { header "__ranges/enable_view.h" }
1745    module filter_view {
1746      header "__ranges/filter_view.h"
1747      export std.functional.bind_back
1748    }
1749    module from_range                     { header "__ranges/from_range.h" }
1750    module iota_view                      { header "__ranges/iota_view.h" }
1751    module istream_view                   { header "__ranges/istream_view.h" }
1752    module join_view                      { header "__ranges/join_view.h" }
1753    module lazy_split_view {
1754      header "__ranges/lazy_split_view.h"
1755      export std.functional.bind_back
1756    }
1757    module movable_box                    { header "__ranges/movable_box.h" }
1758    module non_propagating_cache          { header "__ranges/non_propagating_cache.h" }
1759    module owning_view                    { header "__ranges/owning_view.h" }
1760    module range_adaptor                  { header "__ranges/range_adaptor.h" }
1761    module rbegin                         { header "__ranges/rbegin.h" }
1762    module ref_view                       { header "__ranges/ref_view.h" }
1763    module rend                           { header "__ranges/rend.h" }
1764    module repeat_view                    { header "__ranges/repeat_view.h" }
1765    module reverse_view                   { header "__ranges/reverse_view.h" }
1766    module single_view                    { header "__ranges/single_view.h" }
1767    module size                           { header "__ranges/size.h" }
1768    module split_view {
1769      header "__ranges/split_view.h"
1770      export std.functional.bind_back
1771    }
1772    module subrange {
1773      header "__ranges/subrange.h"
1774      export std.ranges.subrange_fwd
1775    }
1776    module subrange_fwd {
1777      header "__fwd/subrange.h"
1778    }
1779    module take_view {
1780      header "__ranges/take_view.h"
1781      export std.functional.bind_back
1782    }
1783    module take_while_view {
1784      header "__ranges/take_while_view.h"
1785      export std.functional.bind_back
1786    }
1787    module to {
1788      header "__ranges/to.h"
1789      export std.functional.bind_back
1790    }
1791    module transform_view {
1792      header "__ranges/transform_view.h"
1793      export std.functional.bind_back
1794    }
1795    module view_interface {
1796      header "__ranges/view_interface.h"
1797    }
1798    module views {
1799      header "__ranges/views.h"
1800    }
1801    module zip_view {
1802      header "__ranges/zip_view.h"
1803      export std.utility.pair
1804    }
1805
1806    header "ranges"
1807    export *
1808  } // module ranges
1809
1810  module ratio {
1811    header "ratio"
1812    export *
1813  }
1814
1815  module regex {
1816    header "regex"
1817    export *
1818  }
1819
1820  module scoped_allocator {
1821    header "scoped_allocator"
1822    export *
1823  }
1824
1825  module semaphore {
1826    header "semaphore"
1827    export *
1828  }
1829
1830  module set {
1831    header "set"
1832    export *
1833  }
1834
1835  module shared_mutex {
1836    header "shared_mutex"
1837    export *
1838  }
1839
1840  module source_location {
1841    header "source_location"
1842    export *
1843  }
1844
1845  module span {
1846    module fwd { header "__fwd/span.h" }
1847
1848    header "span"
1849    export *
1850  }
1851
1852  module sstream {
1853    module fwd { header "__fwd/sstream.h" }
1854
1855    header "sstream"
1856    export *
1857  }
1858
1859  module stack {
1860    module fwd { header "__fwd/stack.h" }
1861
1862    header "stack"
1863    export *
1864  }
1865
1866  module stdexcept {
1867    header "stdexcept"
1868    export *
1869  }
1870
1871  module stop_token {
1872    module atomic_unique_lock     { header "__stop_token/atomic_unique_lock.h" }
1873    module intrusive_list_view    { header "__stop_token/intrusive_list_view.h" }
1874    module intrusive_shared_ptr   { header "__stop_token/intrusive_shared_ptr.h" }
1875    module stop_callback          { header "__stop_token/stop_callback.h" }
1876    module stop_source            { header "__stop_token/stop_source.h" }
1877    module stop_state             { header "__stop_token/stop_state.h" }
1878    module stop_token             { header "__stop_token/stop_token.h" }
1879
1880    header "stop_token"
1881    export *
1882  }
1883
1884  module streambuf {
1885    module fwd { header "__fwd/streambuf.h" }
1886
1887    header "streambuf"
1888    export *
1889  }
1890
1891  module string {
1892    module char_traits              { header "__string/char_traits.h" }
1893    module constexpr_c_functions    { header "__string/constexpr_c_functions.h" }
1894    module extern_template_lists    { header "__string/extern_template_lists.h" }
1895    module fwd                      {  header "__fwd/string.h" }
1896
1897    header "string"
1898    export *
1899  }
1900
1901  module string_view {
1902    module fwd { header "__fwd/string_view.h" }
1903
1904    header "string_view"
1905    export *
1906  }
1907
1908  module strstream {
1909    header "strstream"
1910    export *
1911  }
1912
1913  module syncstream {
1914    header "syncstream"
1915    export *
1916  }
1917
1918  module system_error {
1919    module errc               { header "__system_error/errc.h" }
1920    module error_category     { header "__system_error/error_category.h" }
1921    module error_code {
1922      header "__system_error/error_code.h"
1923      export std.system_error.error_category // methods of error_code return that type
1924    }
1925    module error_condition    { header "__system_error/error_condition.h" }
1926    module system_error       { header "__system_error/system_error.h" }
1927    module throw_system_error { header "__system_error/throw_system_error.h" }
1928
1929    header "system_error"
1930    export *
1931  }
1932
1933  module thread {
1934    module formatter              { header "__thread/formatter.h" }
1935    module id                     { header "__thread/id.h" }
1936    module jthread                { header "__thread/jthread.h" }
1937    module poll_with_backoff      { header "__thread/poll_with_backoff.h" }
1938    module this_thread            { header "__thread/this_thread.h" }
1939    module thread                 { header "__thread/thread.h" }
1940    module timed_backoff_policy   { header "__thread/timed_backoff_policy.h" }
1941
1942    module support {
1943      header "__thread/support.h"
1944      export *
1945    }
1946    module support_impl {
1947      textual header "__thread/support/c11.h"
1948      textual header "__thread/support/external.h"
1949      textual header "__thread/support/pthread.h"
1950      textual header "__thread/support/windows.h"
1951    }
1952
1953    header "thread"
1954    export *
1955  }
1956
1957  module tuple {
1958    module find_index               { header "__tuple/find_index.h" }
1959    module ignore                   { header "__tuple/ignore.h" }
1960    module make_tuple_types         { header "__tuple/make_tuple_types.h" }
1961    module sfinae_helpers           { header "__tuple/sfinae_helpers.h" }
1962    module tuple_element            { header "__tuple/tuple_element.h" }
1963    module tuple_indices            { header "__tuple/tuple_indices.h" }
1964    module tuple_like_ext           { header "__tuple/tuple_like_ext.h" }
1965    module tuple_like_no_subrange   { header "__tuple/tuple_like_no_subrange.h" }
1966    module tuple_like               { header "__tuple/tuple_like.h" }
1967    module tuple_size               { header "__tuple/tuple_size.h" }
1968    module tuple_types              { header "__tuple/tuple_types.h" }
1969
1970    header "tuple"
1971    export *
1972  }
1973
1974  module typeindex {
1975    header "typeindex"
1976    export *
1977  }
1978
1979  module typeinfo {
1980    header "typeinfo"
1981    export *
1982  }
1983
1984  module unordered_map {
1985    header "unordered_map"
1986    export *
1987  }
1988
1989  module unordered_set {
1990    header "unordered_set"
1991    export *
1992  }
1993
1994  module utility {
1995    module as_const                   { header "__utility/as_const.h" }
1996    module as_lvalue                  { header "__utility/as_lvalue.h" }
1997    module auto_cast                  {
1998      header "__utility/auto_cast.h"
1999      export std_core.type_traits.decay // the macro expansion uses that trait
2000    }
2001    module cmp                        { header "__utility/cmp.h" }
2002    module convert_to_integral        { header "__utility/convert_to_integral.h" }
2003    module exception_guard            { header "__utility/exception_guard.h" }
2004    module exchange                   { header "__utility/exchange.h" }
2005    module forward_like               { header "__utility/forward_like.h" }
2006    module in_place {
2007      header "__utility/in_place.h"
2008      export std_core.type_traits.integral_constant
2009    }
2010    module integer_sequence           { header "__utility/integer_sequence.h" }
2011    module is_pointer_in_range        { header "__utility/is_pointer_in_range.h" }
2012    module is_valid_range             { header "__utility/is_valid_range.h" }
2013    module move                       { header "__utility/move.h" }
2014    module no_destroy                 { header "__utility/no_destroy.h" }
2015    module pair                       { header "__utility/pair.h" }
2016    module piecewise_construct        { header "__utility/piecewise_construct.h" }
2017    module priority_tag               { header "__utility/priority_tag.h" }
2018    module private_constructor_tag    { header "__utility/private_constructor_tag.h" }
2019    module rel_ops                    { header "__utility/rel_ops.h" }
2020    module scope_guard                { header "__utility/scope_guard.h" }
2021    module small_buffer               { header "__utility/small_buffer.h" }
2022    module swap                       { header "__utility/swap.h" }
2023    module to_underlying              { header "__utility/to_underlying.h" }
2024    module unreachable                { header "__utility/unreachable.h" }
2025
2026    header "utility"
2027    export *
2028  }
2029
2030  module valarray {
2031    header "valarray"
2032    export *
2033  }
2034
2035  module variant {
2036    module fwd       { header "__fwd/variant.h" }
2037    module monostate { header "__variant/monostate.h" }
2038
2039    header "variant"
2040    export *
2041  }
2042
2043  module vector {
2044    module fwd                   { header "__fwd/vector.h" }
2045
2046    module comparison            { header "__vector/comparison.h" }
2047    module container_traits      { header "__vector/container_traits.h" }
2048    module erase                 { header "__vector/erase.h" }
2049    module vector_bool_formatter {
2050      header "__vector/vector_bool_formatter.h"
2051
2052      export std.format.formatter
2053    }
2054    module pmr                   {
2055      header "__vector/pmr.h"
2056
2057      export std.memory_resource.polymorphic_allocator
2058    }
2059    module swap                  { header "__vector/swap.h" }
2060    module vector_bool           {
2061      header "__vector/vector_bool.h"
2062      export std.bit_reference
2063      export std.memory.allocator
2064      export std.vector.comparison
2065      export std.vector.fwd
2066      export std.vector.swap
2067    }
2068    module vector                {
2069      header "__vector/vector.h"
2070      export std.iterator.bounded_iter
2071      export std.iterator.wrap_iter
2072      export std.memory.allocator
2073      export std.vector.comparison
2074      export std.vector.fwd
2075      export std.vector.swap
2076    }
2077
2078    header "vector"
2079    export *
2080  }
2081
2082  // Experimental C++ Standard Library interfaces
2083  module experimental {
2084    module iterator           { header "experimental/iterator" }
2085    module memory             { header "experimental/memory" }
2086    module propagate_const    { header "experimental/propagate_const" }
2087    module type_traits        { header "experimental/type_traits" }
2088    module utility            { header "experimental/utility" }
2089    module simd {
2090      private header "experimental/__simd/aligned_tag.h"
2091      private header "experimental/__simd/declaration.h"
2092      private header "experimental/__simd/reference.h"
2093      private header "experimental/__simd/scalar.h"
2094      private header "experimental/__simd/simd_mask.h"
2095      private header "experimental/__simd/simd.h"
2096      private header "experimental/__simd/traits.h"
2097      private header "experimental/__simd/utility.h"
2098      private header "experimental/__simd/vec_ext.h"
2099      header "experimental/simd"
2100      export *
2101    }
2102  }
2103
2104  // Implementation detail headers that are private to libc++. These modules
2105  // must not be directly imported.
2106  module debug_utils {
2107    module randomize_range              { header "__debug_utils/randomize_range.h" }
2108    module sanitizers                   { header "__debug_utils/sanitizers.h" }
2109    module strict_weak_ordering_check   { header "__debug_utils/strict_weak_ordering_check.h" }
2110  }
2111
2112  module get_fwd {
2113    header "__fwd/get.h"
2114    export std_core.fwd.pair
2115    export std_core.fwd.tuple
2116    export std.array.fwd
2117    export std.complex.fwd
2118    export std.ranges.subrange_fwd
2119    export std.variant.fwd
2120  }
2121
2122  module pstl {
2123    module backend_fwd {
2124      header "__pstl/backend_fwd.h"
2125    }
2126    module backend {
2127      header "__pstl/backend.h"
2128      export * // need to export everything from whatever backend is currently configured
2129    }
2130    module backends {
2131      module default {
2132        header "__pstl/backends/default.h"
2133        export std_core.utility_core.empty
2134      }
2135      module libdispatch {
2136        header "__pstl/backends/libdispatch.h"
2137        export std.pstl.cpu_algos
2138        export std_core.utility_core.empty
2139      }
2140      module serial {
2141        header "__pstl/backends/serial.h"
2142        export std_core.utility_core.empty
2143      }
2144      module std_thread {
2145        header "__pstl/backends/std_thread.h"
2146        export std.pstl.cpu_algos
2147        export std_core.utility_core.empty
2148      }
2149    }
2150    module cpu_algos {
2151      module any_of {
2152        header "__pstl/cpu_algos/any_of.h"
2153      }
2154      module cpu_traits {
2155        header "__pstl/cpu_algos/cpu_traits.h"
2156      }
2157      module fill {
2158        header "__pstl/cpu_algos/fill.h"
2159        export std_core.utility_core.empty
2160      }
2161      module find_if {
2162        header "__pstl/cpu_algos/find_if.h"
2163      }
2164      module for_each {
2165        header "__pstl/cpu_algos/for_each.h"
2166        export std_core.utility_core.empty
2167      }
2168      module merge {
2169        header "__pstl/cpu_algos/merge.h"
2170      }
2171      module stable_sort {
2172        header "__pstl/cpu_algos/stable_sort.h"
2173        export std_core.utility_core.empty
2174      }
2175      module transform {
2176        header "__pstl/cpu_algos/transform.h"
2177      }
2178      module transform_reduce {
2179        header "__pstl/cpu_algos/transform_reduce.h"
2180      }
2181    }
2182    module dispatch           { header "__pstl/dispatch.h" }
2183    module handle_exception   { header "__pstl/handle_exception.h" }
2184  }
2185
2186  // Miscellaneous modules for top-level headers
2187  module bit_reference_fwd {
2188    header "__fwd/bit_reference.h"
2189  }
2190  module bit_reference {
2191    header "__bit_reference"
2192    export std.bit_reference_fwd
2193  }
2194  module hash_table           { header "__hash_table" }
2195  module node_handle          { header "__node_handle" }
2196  module split_buffer         { header "__split_buffer" }
2197  module tree                 { header "__tree" }
2198  module std_mbstate_t {
2199    header "__std_mbstate_t.h"
2200    export *
2201  }
2202  module verbose_abort {
2203    header "__verbose_abort"
2204  }
2205  module internal_assert {
2206    header "__assert"
2207    export *
2208  }
2209
2210  module undef_macros {
2211    textual header "__undef_macros"
2212  }
2213
2214  // This module needs to appear after __tree to work around issues with modules in Objective-C++ mode.
2215  module coroutine {
2216    module coroutine_handle         { header "__coroutine/coroutine_handle.h" }
2217    module coroutine_traits         { header "__coroutine/coroutine_traits.h" }
2218    module noop_coroutine_handle    { header "__coroutine/noop_coroutine_handle.h" }
2219    module trivial_awaitables       { header "__coroutine/trivial_awaitables.h" }
2220
2221    header "coroutine"
2222    export *
2223  }
2224} // module std
2225
2226// C compatibility headers
2227//
2228// These modules need to be their own top-level modules because they depend on the system-provided
2229// headers (via include_next), which are then free to include other C headers provided by libc++.
2230// If we group these headers in a single module, we would end up with circular dependencies.
2231module std_complex_h [system] {
2232  header "complex.h"
2233  export *
2234}
2235module std_ctype_h [system] {
2236  header "ctype.h"
2237  export *
2238}
2239module std_errno_h [system] {
2240  header "errno.h"
2241  export *
2242}
2243module std_fenv_h [system] {
2244  header "fenv.h"
2245  export *
2246}
2247module std_float_h [system] {
2248  header "float.h"
2249  export *
2250}
2251module std_inttypes_h [system] {
2252  header "inttypes.h"
2253  export *
2254}
2255module std_math_h [system] {
2256  header "math.h"
2257  export *
2258}
2259module std_stdatomic_h [system] {
2260  header "stdatomic.h"
2261  export *
2262}
2263module std_stdbool_h [system] {
2264  // <stdbool.h>'s __bool_true_false_are_defined macro requires textual inclusion.
2265  textual header "stdbool.h"
2266}
2267module std_stddef_h [system] {
2268  // <stddef.h>'s __need_* macros require textual inclusion.
2269  textual header "stddef.h"
2270}
2271module std_stdio_h [system] {
2272  // <stdio.h>'s __need_* macros require textual inclusion.
2273  textual header "stdio.h"
2274}
2275module std_stdlib_h [system] {
2276  // <stdlib.h>'s __need_* macros require textual inclusion.
2277  textual header "stdlib.h"
2278}
2279module std_string_h [system] {
2280  header "string.h"
2281  export *
2282}
2283module std_tgmath_h [system] {
2284  header "tgmath.h"
2285  export *
2286}
2287module std_uchar_h [system] {
2288  header "uchar.h"
2289  export *
2290}
2291module std_wchar_h [system] {
2292  // <wchar.h>'s __need_* macros require textual inclusion.
2293  textual header "wchar.h"
2294}
2295module std_wctype_h [system] {
2296  header "wctype.h"
2297  export *
2298}
2299
2300// This header is used by other C compatibility headers so it needs to be in its own module.
2301module std_private_mbstate_t [system] {
2302  header "__mbstate_t.h"
2303  export *
2304}
2305