Remove patterns on 'String'

There's arguably no use case ever for that in the context of on-chain
  Plutus. Strings are really just meant to be used for tracing. They
  aren't meant to be manipulated as heavily as in classic programming
  languages.

crates/aiken-lang/src/ast.rs

@@ -717,11 +717,6 @@ pub enum Pattern<Constructor, Type> {
         value: String,
     },
 
-    String {
-        location: Span,
-        value: String,
-    },
-
     /// The creation of a variable.
     /// e.g. `assert [this_is_a_var, .._] = x`
     Var {
@@ -776,7 +771,6 @@ impl<A, B> Pattern<A, B> {
             | Pattern::Var { location, .. }
             | Pattern::List { location, .. }
             | Pattern::Discard { location, .. }
-            | Pattern::String { location, .. }
             | Pattern::Tuple { location, .. }
             // | Pattern::Concatenate { location, .. }
             | Pattern::Constructor { location, .. } => *location,

crates/aiken-lang/src/format.rs

@@ -1454,8 +1454,6 @@ impl<'comments> Formatter<'comments> {
         let doc = match pattern {
             Pattern::Int { value, .. } => value.to_doc(),
 
-            Pattern::String { value, .. } => self.string(value),
-
             Pattern::Var { name, .. } => name.to_doc(),
 
             Pattern::Assign { name, pattern, .. } => {

crates/aiken-lang/src/parser.rs

@@ -1689,12 +1689,6 @@ pub fn pattern_parser() -> impl Parser<Token, ast::UntypedPattern, Error = Parse
                     location: span,
                 }
             }),
-            select! {Token::String {value} => value}.map_with_span(|value, span| {
-                ast::UntypedPattern::String {
-                    location: span,
-                    value,
-                }
-            }),
             select! {Token::Int {value} => value}.map_with_span(|value, span| {
                 ast::UntypedPattern::Int {
                     location: span,

crates/aiken-lang/src/tipo/pattern.rs

@@ -16,7 +16,7 @@ use super::{
 };
 use crate::{
     ast::{CallArg, Pattern, Span, TypedPattern, UntypedMultiPattern, UntypedPattern},
-    builtins::{int, list, string, tuple},
+    builtins::{int, list, tuple},
 };
 
 pub struct PatternTyper<'a, 'b> {
@@ -286,12 +286,6 @@ impl<'a, 'b> PatternTyper<'a, 'b> {
                 Ok(Pattern::Int { location, value })
             }
 
-            Pattern::String { location, value } => {
-                self.environment.unify(tipo, string(), location, false)?;
-
-                Ok(Pattern::String { location, value })
-            }
-
             Pattern::List {
                 location,
                 elements,

crates/aiken-lang/src/uplc.rs

@@ -871,7 +871,6 @@ impl<'a> CodeGenerator<'a> {
 
                 pattern_vec.append(values);
             }
-            Pattern::String { .. } => todo!("String matching in whens not yet implemented"),
             Pattern::Var { name, .. } => {
                 pattern_vec.push(Air::Void {
                     scope: scope.clone(),
@@ -1060,7 +1059,6 @@ impl<'a> CodeGenerator<'a> {
     ) {
         match pattern {
             Pattern::Int { .. } => unreachable!(),
-            Pattern::String { .. } => unreachable!(),
             Pattern::Var { .. } => unreachable!(),
             Pattern::Assign { .. } => todo!("Nested assign not yet implemented"),
             Pattern::Discard { .. } => {
@@ -1537,7 +1535,6 @@ impl<'a> CodeGenerator<'a> {
             }
             Pattern::Assign { .. } => todo!("Nested assign is not yet done"),
             Pattern::Int { .. } => unimplemented!(),
-            Pattern::String { .. } => unimplemented!(),
         }
     }
 
@@ -1569,7 +1566,7 @@ impl<'a> CodeGenerator<'a> {
             )
         }
         match pattern {
-            Pattern::Int { .. } | Pattern::String { .. } => unreachable!(),
+            Pattern::Int { .. } => unreachable!(),
             Pattern::Var { name, .. } => {
                 pattern_vec.push(Air::Let {
                     name: name.clone(),
@@ -1690,7 +1687,6 @@ impl<'a> CodeGenerator<'a> {
     ) {
         match pattern {
             Pattern::Int { .. } => todo!(),
-            Pattern::String { .. } => todo!(),
             Pattern::Var { .. } => todo!(),
             Pattern::Assign { .. } => todo!(),
             Pattern::Discard { .. } => todo!(),
@@ -1736,7 +1732,6 @@ impl<'a> CodeGenerator<'a> {
                             );
                         }
                         Pattern::Int { .. } => todo!(),
-                        Pattern::String { .. } => todo!(),
                         Pattern::Assign { .. } => todo!(),
                         Pattern::Discard { .. } => {
                             names.push("_".to_string());
@@ -1904,7 +1899,6 @@ impl<'a> CodeGenerator<'a> {
     ) {
         match pattern {
             Pattern::Int { .. } => unreachable!(),
-            Pattern::String { .. } => unreachable!(),
             Pattern::Var { name, .. } => {
                 pattern_vec.append(value_vec);
 
@@ -2651,7 +2645,6 @@ impl<'a> CodeGenerator<'a> {
                     (false, tuple_name)
                 }
                 Pattern::Int { .. } => todo!(),
-                Pattern::String { .. } => todo!(),
                 Pattern::Assign { .. } => todo!(),
             };