source: src/ResolvExpr/Typeops.hpp @ 508cff0

//
// Cforall Version 1.0.0 Copyright (C) 2015 University of Waterloo
//
// The contents of this file are covered under the licence agreement in the
// file "LICENCE" distributed with Cforall.
//
// Typeops.hpp --
//
// Author           : Richard C. Bilson
// Created On       : Sun May 17 07:28:22 2015
// Last Modified By : Andrew Beach
// Last Modified On : Wed Jan 18 11:54:00 2023
// Update Count     : 7
//

#pragma once

#include <vector>

#include "AST/Type.hpp"

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;

        if ( begin == end )     {
                *out++ = ListType();
                return;
        } // if

        InputIterator current = begin;
        begin++;

        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;
        }

        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

namespace ast {
        // in TypeEnvironment.cpp
        bool isFtype( const ast::Type * type );
} // namespace ast

// Local Variables: //
// tab-width: 4 //
// mode: c++ //
// compile-command: "make install" //
// End: //