Changeset 13de4478 for src/ResolvExpr/typeops.h

Timestamp:

Apr 23, 2024, 1:37:17 PM (4 weeks ago)

Author:

Andrew Beach <ajbeach@…>

Branches:

master

Children:

4a3eb1c

Parents:

15215f02

Message:

Updated files in ResolvExpr? to the new indentation style. It seems the remaining places have reason to break from the style.

File:

• src/ResolvExpr/typeops.h (modified) (1 diff)

src/ResolvExpr/typeops.h

@@ -21 +21 @@
 
 namespace ResolvExpr {
-        class TypeEnvironment;
 
-        // combos: takes a list of sets and returns a set of lists representing every possible way of forming a list by
-        // picking one element out of each set
-        template< typename InputIterator, typename OutputIterator >
-        void combos( InputIterator begin, InputIterator end, OutputIterator out ) {
-                typedef typename InputIterator::value_type SetType;
-                typedef typename std::vector< typename SetType::value_type > ListType;
+class TypeEnvironment;
 
-                if ( begin == end )     {
-                        *out++ = ListType();
-                        return;
-                } // if
+// combos: takes a list of sets and returns a set of lists representing every possible way of forming a list by
+// picking one element out of each set
+template< typename InputIterator, typename OutputIterator >
+void combos( InputIterator begin, InputIterator end, OutputIterator out ) {
+        typedef typename InputIterator::value_type SetType;
+        typedef typename std::vector< typename SetType::value_type > ListType;
 
-                InputIterator current = begin;
-                begin++;
+        if ( begin == end )     {
+                *out++ = ListType();
+                return;
+        } // if
 
-                std::vector< ListType > recursiveResult;
-                combos( begin, end, back_inserter( recursiveResult ) );
+        InputIterator current = begin;
+        begin++;
 
-                for ( const auto& i : recursiveResult ) for ( const auto& j : *current ) {
-                        ListType result;
-                        std::back_insert_iterator< ListType > inserter = back_inserter( result );
-                        *inserter++ = j;
-                        std::copy( i.begin(), i.end(), inserter );
-                        *out++ = result;
+        std::vector< ListType > recursiveResult;
+        combos( begin, end, back_inserter( recursiveResult ) );
+
+        for ( const auto& i : recursiveResult ) for ( const auto& j : *current ) {
+                ListType result;
+                std::back_insert_iterator< ListType > inserter = back_inserter( result );
+                *inserter++ = j;
+                std::copy( i.begin(), i.end(), inserter );
+                *out++ = result;
+        }
+}
+
+/// Flatten tuple type into existing list of types.
+inline void flatten(
+        const ast::Type * type, std::vector< ast::ptr< ast::Type > > & out
+) {
+        if ( auto tupleType = dynamic_cast< const ast::TupleType * >( type ) ) {
+                for ( const ast::Type * t : tupleType->types ) {
+                        flatten( t, out );
                 }
+        } else {
+                out.emplace_back( type );
+        }
+}
+
+/// Flatten tuple type into list of types.
+inline std::vector< ast::ptr< ast::Type > > flatten( const ast::Type * type ) {
+        std::vector< ast::ptr< ast::Type > > out;
+        out.reserve( type->size() );
+        flatten( type, out );
+        return out;
+}
+
+template< typename Iter >
+const ast::Type * tupleFromTypes( Iter crnt, Iter end ) {
+        std::vector< ast::ptr< ast::Type > > types;
+        while ( crnt != end ) {
+                // it is guaranteed that a ttype variable will be bound to a flat tuple, so ensure
+                // that this results in a flat tuple
+                flatten( *crnt, types );
+
+                ++crnt;
         }
 
-        /// flatten tuple type into existing list of types
-        inline void flatten(
-                const ast::Type * type, std::vector< ast::ptr< ast::Type > > & out
-        ) {
-                if ( auto tupleType = dynamic_cast< const ast::TupleType * >( type ) ) {
-                        for ( const ast::Type * t : tupleType->types ) {
-                                flatten( t, out );
-                        }
-                } else {
-                        out.emplace_back( type );
-                }
-        }
+        return new ast::TupleType( std::move(types) );
+}
 
-        /// flatten tuple type into list of types
-        inline std::vector< ast::ptr< ast::Type > > flatten( const ast::Type * type ) {
-                std::vector< ast::ptr< ast::Type > > out;
-                out.reserve( type->size() );
-                flatten( type, out );
-                return out;
-        }
+inline const ast::Type * tupleFromTypes(
+        const std::vector< ast::ptr< ast::Type > > & tys
+) {
+        return tupleFromTypes( tys.begin(), tys.end() );
+}
 
-        template< typename Iter >
-        const ast::Type * tupleFromTypes( Iter crnt, Iter end ) {
-                std::vector< ast::ptr< ast::Type > > types;
-                while ( crnt != end ) {
-                        // it is guaranteed that a ttype variable will be bound to a flat tuple, so ensure
-                        // that this results in a flat tuple
-                        flatten( *crnt, types );
-
-                        ++crnt;
-                }
-
-                return new ast::TupleType{ std::move(types) };
-        }
-
-        inline const ast::Type * tupleFromTypes(
-                const std::vector< ast::ptr< ast::Type > > & tys
-        ) {
-                return tupleFromTypes( tys.begin(), tys.end() );
-        }
 } // namespace ResolvExpr