with-only-representation := λ(: tt List<Type>). (: (
   (let rt tt)
   (match tt (
      ()
      ( (LCons( p1 rst )) (
         (set rt (cons(
            (with-only-representation p1)
            (with-only-representation rst)
         )))
      ))
      ( LEOF () )
   ))
   rt
) List<Type>);

with-only-representation := λ(: tt Type). (: (
   (let return tt)
   (match tt (
      ()
      ( (TAnd( lt rt )) (
         (let lt2 (with-only-representation lt))
         (let rt2 (with-only-representation rt))
         (if (non-zero lt2) (
            (if (non-zero rt2) (
               (set return (TAnd( (close lt2) (close rt2) )))
            ) (
               (set return lt2)
            ))
         ) (
            (if (non-zero rt2) (
               (set return rt2)
            ) (
               (set return TAny)
            ))
         ))
      ))
      ( (TGround( 'Constant_s LEOF )) () )
      ( (TGround( 'Literal_s LEOF )) () )
      ( (TGround( 'StackVariable_s LEOF )) () )
      ( (TGround( 'LocalVariable_s LEOF )) () )
      ( (TGround( 'GlobalVariable_s LEOF )) () )
      ( (TGround( 'Reg8_s LEOF )) () )
      ( (TGround( 'Reg16_s LEOF )) () )
      ( (TGround( 'Reg32_s LEOF )) () )
      ( (TGround( 'Reg64_s LEOF )) () )
      ( (TGround( tag ps )) (set return TAny) )
      ( TAny () )
      ( (TVar _) (set return TAny) )
   ))
   return
) Type);