can for normal (no-list) as

crates/compiler/can/src/copy.rs

@@ -654,6 +654,7 @@ fn deep_copy_pattern_help<C: CopyEnv>(
 
     match pat {
         Identifier(s) => Identifier(*s),
+        As(subpattern, s) => As(Box::new(subpattern.map(|p| go_help!(p))), *s),
         AppliedTag {
             whole_var,
             ext_var,

crates/compiler/can/src/debug/pretty_print.rs

@@ -431,6 +431,9 @@ fn pattern<'a>(
         | AbilityMemberSpecialization {
             specializes: sym, ..
         } => pp_sym(c, f, *sym),
+        As(subpattern, symbol) => pattern(c, prec, f, &subpattern.value)
+            .append(f.text(" as "))
+            .append(pp_sym(c, f, *symbol)),
         AppliedTag {
             tag_name,
             arguments,

crates/compiler/can/src/def.rs

@@ -1967,6 +1967,12 @@ fn pattern_to_vars_by_symbol(
             vars_by_symbol.insert(*symbol, expr_var);
         }
 
+        As(subpattern, symbol) => {
+            vars_by_symbol.insert(*symbol, expr_var);
+
+            pattern_to_vars_by_symbol(vars_by_symbol, &subpattern.value, expr_var);
+        }
+
         AbilityMemberSpecialization {
             ident,
             specializes: _,

crates/compiler/can/src/exhaustive.rs

@@ -301,6 +301,7 @@ fn sketch_pattern(pattern: &crate::pattern::Pattern) -> SketchedPattern {
     use SketchedPattern as SP;
 
     match pattern {
+        As(subpattern, _) => sketch_pattern(&subpattern.value),
         &NumLiteral(_, _, IntValue::I128(n), _) | &IntLiteral(_, _, _, IntValue::I128(n), _) => {
             SP::Literal(Literal::Int(n))
         }

crates/compiler/can/src/module.rs

@@ -929,6 +929,14 @@ fn fix_values_captured_in_closure_pattern(
                 );
             }
         }
+        As(subpattern, _) => {
+            fix_values_captured_in_closure_pattern(
+                &mut subpattern.value,
+                no_capture_symbols,
+                closure_captures,
+            );
+        }
+
         Identifier(_)
         | NumLiteral(..)
         | IntLiteral(..)

crates/compiler/can/src/pattern.rs

@@ -22,6 +22,7 @@ use roc_types::types::{LambdaSet, OptAbleVar, PatternCategory, Type};
 #[derive(Clone, Debug)]
 pub enum Pattern {
     Identifier(Symbol),
+    As(Box<Loc<Pattern>>, Symbol),
     AppliedTag {
         whole_var: Variable,
         ext_var: Variable,
@@ -94,6 +95,7 @@ impl Pattern {
         use Pattern::*;
         match self {
             Identifier(_) => None,
+            As(pattern, _) => pattern.value.opt_var(),
 
             AppliedTag { whole_var, .. } => Some(*whole_var),
             UnwrappedOpaque { whole_var, .. } => Some(*whole_var),
@@ -129,6 +131,7 @@ impl Pattern {
             | MalformedPattern(..)
             | AbilityMemberSpecialization { .. } => true,
             RecordDestructure { destructs, .. } => destructs.is_empty(),
+            As(pattern, _identifier) => pattern.value.surely_exhaustive(),
             List { patterns, .. } => patterns.surely_exhaustive(),
             AppliedTag { .. }
             | NumLiteral(..)
@@ -151,6 +154,7 @@ impl Pattern {
 
         match self {
             Identifier(_) => C::PatternDefault,
+            As(pattern, _) => pattern.value.category(),
 
             AppliedTag { tag_name, .. } => C::Ctor(tag_name.clone()),
             UnwrappedOpaque { opaque, .. } => C::Opaque(*opaque),
@@ -832,6 +836,10 @@ impl<'a> BindingsFromPattern<'a> {
                         } => {
                             return Some((*symbol, loc_pattern.region));
                         }
+                        As(pattern, symbol) => {
+                            stack.push(Pattern(pattern));
+                            return Some((*symbol, loc_pattern.region));
+                        }
                         AppliedTag {
                             arguments: loc_args,
                             ..

crates/compiler/can/src/traverse.rs

@@ -476,6 +476,9 @@ pub fn walk_pattern<V: Visitor>(visitor: &mut V, pattern: &Pattern) {
 
     match pattern {
         Identifier(..) => { /* terminal */ }
+        As(subpattern, _symbol) => {
+            visitor.visit_pattern(&subpattern.value, subpattern.region, None)
+        }
         AppliedTag { arguments, .. } => arguments
             .iter()
             .for_each(|(v, lp)| visitor.visit_pattern(&lp.value, lp.region, Some(*v))),