diff --git a/compiler/erg_compiler/context/compare.rs b/compiler/erg_compiler/context/compare.rs
index 693b6a19..b353cdc2 100644
--- a/compiler/erg_compiler/context/compare.rs
+++ b/compiler/erg_compiler/context/compare.rs
@@ -366,7 +366,7 @@ impl Context {
     /// assert supertype_of(Bool, Bool)
     /// ```
     /// This function does not consider the nominal subtype relation.
-    /// Use `rec_full_supertype_of` for complete judgement.
+    /// Use `supertype_of` for complete judgement.
     /// 単一化、評価等はここでは行わない、スーパータイプになる可能性があるかだけ判定する
     /// ので、lhsが(未連携)型変数の場合は単一化せずにtrueを返す
     pub(crate) fn structural_supertype_of(&self, lhs: &Type, rhs: &Type) -> bool {
diff --git a/compiler/erg_parser/parse.rs b/compiler/erg_parser/parse.rs
index 09670b4b..ce05e8f6 100644
--- a/compiler/erg_parser/parse.rs
+++ b/compiler/erg_parser/parse.rs
@@ -2121,8 +2121,8 @@ impl Parser {
         Ok(bounds)
     }
 
-    fn convert_type_arg_to_bound(&mut self, _arg: PosArg) -> ParseResult<TypeBoundSpec> {
-        match _arg.expr {
+    fn convert_type_arg_to_bound(&mut self, arg: PosArg) -> ParseResult<TypeBoundSpec> {
+        match arg.expr {
             Expr::TypeAsc(tasc) => {
                 let lhs = self
                     .convert_rhs_to_sig(*tasc.expr)
@@ -2529,6 +2529,26 @@ impl Parser {
                         .map_err(|_| self.stack_dec())?;
                     self.level -= 1;
                     Ok(TypeSpec::Interval { op, lhs, rhs })
+                } else if bin.op.kind == TokenKind::AndOp {
+                    let mut args = bin.args.into_iter();
+                    let lhs = self
+                        .convert_rhs_to_type_spec(*args.next().unwrap())
+                        .map_err(|_| self.stack_dec())?;
+                    let rhs = self
+                        .convert_rhs_to_type_spec(*args.next().unwrap())
+                        .map_err(|_| self.stack_dec())?;
+                    self.level -= 1;
+                    Ok(TypeSpec::and(lhs, rhs))
+                } else if bin.op.kind == TokenKind::OrOp {
+                    let mut args = bin.args.into_iter();
+                    let lhs = self
+                        .convert_rhs_to_type_spec(*args.next().unwrap())
+                        .map_err(|_| self.stack_dec())?;
+                    let rhs = self
+                        .convert_rhs_to_type_spec(*args.next().unwrap())
+                        .map_err(|_| self.stack_dec())?;
+                    self.level -= 1;
+                    Ok(TypeSpec::or(lhs, rhs))
                 } else {
                     self.level -= 1;
                     let err = ParseError::simple_syntax_error(line!() as usize, bin.loc());