complete string interpolation

src/main.rs

@@ -58,12 +58,12 @@ use crate::base::*;
 
 pub fn main() {
     let src = "
-fn foo {
-    \"this is a docstring\"
-    () -> :foo
-    (_) -> :bar
-}
-doc (foo)
+let foo = :foo
+let bar = 42
+let baz = \"foo bar baz\"
+let quux = (1, 2, [3, 4, #{:five 6, :seven 8}])
+\"{foo} {bar} {baz}
+{quux} {fuzz} TADA!\"
     ";
     let (tokens, lex_errs) = lexer().parse(src).into_output_errors();
     if !lex_errs.is_empty() {

src/parser.rs

@@ -34,16 +34,18 @@ impl<'src> fmt::Display for MatchClause<'src> {
 }
 
 #[derive(Clone, Debug, PartialEq, Eq)]
-pub enum StringPart<'src> {
-    Data(&'src str),
-    Word(&'src str),
+pub enum StringPart {
+    Data(String),
+    Word(String),
+    Inline(String),
 }
 
-impl<'src> fmt::Display for StringPart<'src> {
-    fn fmt(self: &StringPart<'src>, f: &mut fmt::Formatter) -> fmt::Result {
+impl fmt::Display for StringPart {
+    fn fmt(self: &StringPart, f: &mut fmt::Formatter) -> fmt::Result {
         let rep = match self {
-            StringPart::Data(s) => format!("{{{s}}}"),
-            StringPart::Word(s) => s.to_string(),
+            StringPart::Word(s) => format!("{{{s}}}"),
+            StringPart::Data(s) => s.to_string(),
+            StringPart::Inline(s) => s.to_string(),
         };
         write!(f, "{}", rep)
     }
@@ -59,7 +61,7 @@ pub enum Ast<'src> {
     Keyword(&'src str),
     Word(&'src str),
     String(&'src str),
-    Interpolated(Vec<Spanned<StringPart<'src>>>),
+    Interpolated(Vec<Spanned<StringPart>>),
     Block(Vec<Spanned<Self>>),
     If(Box<Spanned<Self>>, Box<Spanned<Self>>, Box<Spanned<Self>>),
     Tuple(Vec<Spanned<Self>>),
@@ -91,7 +93,7 @@ impl fmt::Display for Ast<'_> {
             Ast::Interpolated(strs) => {
                 write!(
                     f,
-                    "String: \"{}\"",
+                    "Interpolated: \"{}\"",
                     strs.iter()
                         .map(|(s, _)| s.to_string())
                         .collect::<Vec<_>>()
@@ -251,6 +253,7 @@ pub enum Pattern<'src> {
     Boolean(bool),
     Number(f64),
     String(&'src str),
+    Interpolated(Vec<StringPart>),
     Keyword(&'src str),
     Word(&'src str),
     As(&'src str, &'src str),
@@ -300,10 +303,26 @@ impl fmt::Display for Pattern<'_> {
                     .join(", ")
             ),
             Pattern::Pair(key, value) => write!(f, ":{} {}", key, value.0),
+            Pattern::Interpolated(strprts) => write!(
+                f,
+                "\"{}\"",
+                strprts
+                    .iter()
+                    .map(|part| part.to_string())
+                    .collect::<Vec<_>>()
+                    .join("")
+            ),
         }
     }
 }
 
+fn is_word_char(c: char) -> bool {
+    if c.is_ascii_alphanumeric() {
+        return true;
+    };
+    matches!(c, '_' | '/' | '?' | '!')
+}
+
 // TODO: write this
 // 1. we need an enum for a return type
 //    either a string part or a word part
@@ -311,8 +330,81 @@ impl fmt::Display for Pattern<'_> {
 // 3. this should loop through the string and allow for escaping braces
 //    consider using Rust-style escapes: {{}}, rather than \{\}
 // {{{foo}}}
-pub fn parse_string<'src>(s: &'src str) -> Vec<StringPart<'src>> {
-    vec![]
+fn parse_string(s: &str, span: SimpleSpan) -> Result<Vec<Spanned<StringPart>>, String> {
+    let mut parts = vec![];
+    let mut current_part = String::new();
+    let mut start = span.start;
+    let mut is_word = false;
+
+    let mut chars = s.char_indices();
+    while let Some((i, char)) = chars.next() {
+        match char {
+            '{' => {
+                if is_word {
+                    return Err("interpolations must only contain words".to_string());
+                };
+                match chars.next() {
+                    None => return Err("unclosed brace".to_string()),
+                    Some((_, '{')) => current_part.push('{'),
+                    Some((i, c)) => {
+                        if !current_part.is_empty() {
+                            parts.push((
+                                StringPart::Data(current_part),
+                                SimpleSpan::new(start, start + i),
+                            ));
+                        };
+                        current_part = String::new();
+                        start = i;
+                        is_word = true;
+                        if c.is_ascii_lowercase() {
+                            current_part.push(c);
+                        } else {
+                            return Err("interpolations must only contain words".to_string());
+                        }
+                    }
+                }
+            }
+            '}' => {
+                if is_word {
+                    parts.push((
+                        StringPart::Word(current_part),
+                        SimpleSpan::new(start, start + i),
+                    ));
+                    current_part = String::new();
+                    start = i;
+                    is_word = false;
+                } else {
+                    match chars.next() {
+                        None => return Err("unclosed brace".to_string()),
+                        Some((_, c)) => current_part.push(c),
+                    }
+                }
+            }
+            _ => {
+                if is_word {
+                    if is_word_char(char) {
+                        current_part.push(char)
+                    } else {
+                        return Err("interpolations must only contain words".to_string());
+                    }
+                } else {
+                    current_part.push(char)
+                }
+            }
+        }
+    }
+
+    parts.push((
+        if is_word {
+            StringPart::Word(current_part)
+        } else if current_part == s {
+            StringPart::Inline(current_part)
+        } else {
+            StringPart::Data(current_part)
+        },
+        SimpleSpan::new(start, span.end),
+    ));
+    Ok(parts)
 }
 
 pub fn parser<'src, I>(
@@ -448,7 +540,16 @@ where
     }
     .map_with(|v, e| (v, e.span()));
 
-    let string = select! {Token::String(s) => Ast::String(s)}.map_with(|s, e| (s, e.span()));
+    let string = select! {Token::String(s) => s}.try_map_with(|s, e| {
+        let parsed = parse_string(s, e.span());
+        match parsed {
+            Ok(parts) => match parts[0] {
+                (StringPart::Inline(_), _) => Ok((Ast::String(s), e.span())),
+                _ => Ok((Ast::Interpolated(parts), e.span())),
+            },
+            Err(msg) => Err(Rich::custom(e.span(), msg)),
+        }
+    });
 
     let tuple = simple
         .clone()

src/value.rs

@@ -175,3 +175,37 @@ impl<'src> PartialEq for Value<'src> {
 }
 
 impl Eq for Value<'_> {}
+
+impl Value<'_> {
+    pub fn interpolate(&self) -> String {
+        match self {
+            Value::Nil => String::new(),
+            Value::Boolean(b) => format!("{b}"),
+            Value::Number(n) => format!("{n}"),
+            Value::Keyword(k) => format!(":{k}"),
+            Value::AllocatedString(s) => format!("{s}"),
+            Value::InternedString(s) => s.to_string(),
+            Value::Box(_, x) => x.borrow().interpolate(),
+            Value::Tuple(xs) => xs
+                .iter()
+                .map(|x| x.interpolate())
+                .collect::<Vec<_>>()
+                .join(", "),
+            Value::List(xs) => xs
+                .iter()
+                .map(|x| x.interpolate())
+                .collect::<Vec<_>>()
+                .join(", "),
+            Value::Dict(xs) => xs
+                .iter()
+                .map(|(k, v)| format!(":{} {}", k, v.interpolate()))
+                .collect::<Vec<_>>()
+                .join(", "),
+            Value::Fn(x) => format!("fn {}", x.name.to_string()),
+            Value::Placeholder => unreachable!(),
+            Value::Args(_) => unreachable!(),
+            Value::Recur(_) => unreachable!(),
+            Value::Base(_) => unreachable!(),
+        }
+    }
+}

src/vm.rs

@@ -282,7 +282,28 @@ pub fn eval<'src, 'a>(
         Ast::Number(n) => Ok(Value::Number(*n)),
         Ast::Keyword(k) => Ok(Value::Keyword(k)),
         Ast::String(s) => Ok(Value::InternedString(s)),
-        Ast::Interpolated(s) => todo!(),
+        Ast::Interpolated(parts) => {
+            let mut interpolated = String::new();
+            for part in parts {
+                match &part.0 {
+                    StringPart::Data(s) => interpolated.push_str(s.as_str()),
+                    StringPart::Word(w) => {
+                        let val = if let Some((_, value)) =
+                            ctx.iter().rev().find(|(name, _)| w == name)
+                        {
+                            value.clone()
+                        } else {
+                            return Err(LudusError {
+                                msg: format!("unbound name {w}"),
+                            });
+                        };
+                        interpolated.push_str(val.interpolate().as_str())
+                    }
+                    StringPart::Inline(_) => unreachable!(),
+                }
+            }
+            Ok(Value::AllocatedString(Rc::new(interpolated)))
+        }
         Ast::Block(exprs) => {
             let to = ctx.len();
             let mut result = Value::Nil;