koatl 0.1.37__tar.gz → 0.1.38__tar.gz

{koatl-0.1.37 → koatl-0.1.38}/Cargo.lock

@@ -99,7 +99,7 @@ checksum = "f4c7245a08504955605670dbf141fceab975f15ca21570696aebe9d2e71576bd"
 
 [[package]]
 name = "koatl"
-version = "0.1.37"
+version = "0.1.38"
 dependencies = [
  "ariadne",
  "koatl-core",

{koatl-0.1.37 → koatl-0.1.38}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: koatl
-Version: 0.1.37
+Version: 0.1.38
 Classifier: Programming Language :: Rust
 Classifier: Programming Language :: Python :: Implementation :: CPython
 Classifier: Programming Language :: Python :: Implementation :: PyPy

{koatl-0.1.37 → koatl-0.1.38}/koatl/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "koatl"
-version = "0.1.37"
+version = "0.1.38"
 edition = "2021"
 
 [lib]

{koatl-0.1.37 → koatl-0.1.38}/koatl/python/koatl/prelude/__init__.tl

@@ -43,6 +43,7 @@ Extension.method(str, "search")& (str, regex) => Pattern(regex).search(str)
 
 import koatl.std.lazy_module.LazyModule
 
+export import koatl.std.trait.*
 export Result, Ok, Err, Env, Memo, Async, AsyncMemo
 export std = LazyModule("koatl.std")
 

{koatl-0.1.37 → koatl-0.1.38}/koatl/python/koatl/runtime/__init__.py

@@ -19,7 +19,6 @@ meta_finder.install_hook()
 from .virtual import *
 from .record import *
 from .helpers import *
-from .classes import *
 
 
 def dummy(name):
@@ -52,7 +51,6 @@ __tl__ = SimpleNamespace(
     **{name: helpers.__dict__[name] for name in helpers.__all__},
     **{name: record.__dict__[name] for name in record.__all__},
     **{name: virtual.__dict__[name] for name in virtual.__all__},
-    **{name: classes.__dict__[name] for name in classes.__all__},
 )
 
 
@@ -61,5 +59,4 @@ __all__ = [
     *helpers.__all__,
     *record.__all__,
     *virtual.__all__,
-    *classes.__all__,
 ]

{koatl-0.1.37 → koatl-0.1.38/koatl}/python/koatl/std/alg/base.tl

@@ -1,3 +1,5 @@
+import koatl.std.trait.Trait
+
 export Monad = class(Trait):
     """
     Abstract base class for monads.

{koatl-0.1.37 → koatl-0.1.38/koatl}/python/koatl/std/iter.tl

@@ -1,7 +1,8 @@
 import itertools
 import builtins
-import .alg.(Traversable, Ok, Err, Memo, Async, AsyncMemo, Result)
 
+import koatl.std.trait.Trait
+import .alg.(Traversable, Ok, Err, Memo, Async, AsyncMemo, Result)
 
 export Iterable = class(Traversable, Trait):
     iter = Trait.abstract& self => None

koatl-0.1.37/koatl/python/koatl/runtime/classes.py → koatl-0.1.38/koatl/python/koatl/std/trait.py

@@ -40,7 +40,7 @@ class MappingMeta(type):
         return [(k, v) for k, v in inspect.getmembers(self) if not k.startswith("_")]
 
 
-# A utility base class to inherit from to enable __getitem__ method lookup on types and thus destructuring.
+# A utility base class to inherit from that implements Mapping on the type and thus destructuring.
 class Class(metaclass=MappingMeta):
     pass
 

{koatl-0.1.37 → koatl-0.1.38}/koatl-core/parser/src/lexer.rs

@@ -541,6 +541,19 @@ where
         }
     }
 
+    fn parse_char(&mut self, c: char) -> TResult<'src, ()> {
+        let start = self.cursor();
+
+        if self.next() != Some(c) {
+            return Err(Rich::custom(
+                self.span_since(&start),
+                format!("expected '{c}'"),
+            ));
+        }
+
+        Ok(())
+    }
+
     fn parse_seq(&mut self, seq: &str) -> TResult<'src, ()> {
         let start = self.cursor();
 
@@ -579,78 +592,67 @@ where
         }
     }
 
-    fn parse_regular_str(&mut self) -> TResult<'src, Spanned<Token<'src>>> {
-        let start = self.cursor();
-
-        self.parse_seq("\"")?;
-
-        let mut s = String::new();
-        loop {
-            if self.try_parse(|x| x.parse_seq("\"")).is_ok() {
-                return Ok(Token::Str(s).spanned(self.span_since(&start)));
-            }
-
-            if self.try_parse(|x| x.parse_newline()).is_ok() {
-                return Err(Rich::custom(self.span_since(&start), "unterminated string"));
-            }
-
-            s.push(self.parse_escaped_char()?);
-        }
-    }
-
-    fn parse_verbatim_str(&mut self) -> TResult<'src, Spanned<Token<'src>>> {
-        let start = self.cursor();
-
-        self.parse_seq("\"\"\"")?;
-
-        let mut s = String::new();
-        loop {
-            if self.try_parse(|x| x.parse_seq("\"\"\"")).is_ok() {
-                return Ok(Token::Str(s).spanned(self.span_since(&start)));
-            }
-
-            s.push(self.next().ok_or_else(|| {
-                Rich::custom(self.span_since(&start), "unterminated verbatim string")
-            })?);
-        }
-    }
-
-    fn parse_fstr_inner(&mut self, ending: &str, verbatim: bool) -> TResult<'src, TokenList<'src>> {
+    fn parse_fstr_inner(
+        &mut self,
+        ending_char: char,
+        ending_char_count: u32,
+        verbatim: bool,
+    ) -> TResult<'src, TokenList<'src>> {
         let mut marker = self.cursor();
         let mut tokens = vec![];
         let mut current_str = String::new();
 
+        let mut seen_quotes = 0;
+        let mut ending_marker = self.input.save();
         loop {
-            if self.look_ahead(|x| x.parse_seq(ending)).is_ok() {
-                if tokens.len() == 0 {
-                    tokens.push(Token::FstrBegin(current_str).spanned(self.span_since(&marker)));
-                } else {
-                    tokens.push(Token::FstrContinue(current_str).spanned(self.span_since(&marker)));
-                }
-
-                return Ok(TokenList(tokens));
+            if !verbatim && self.try_parse(|x| x.parse_newline()).is_ok() {
+                return Err(Rich::custom(
+                    self.span_since(&marker),
+                    "unterminated fstring",
+                ));
             }
 
-            if !verbatim && self.try_parse(|x| x.parse_newline()).is_ok() {
+            let Some(peeked) = self.peek() else {
                 return Err(Rich::custom(
                     self.span_since(&marker),
                     "unterminated fstring",
                 ));
+            };
+
+            let mut save_marker = false;
+
+            if peeked == ending_char {
+                seen_quotes += 1;
+
+                if seen_quotes == ending_char_count {
+                    if tokens.len() == 0 {
+                        tokens
+                            .push(Token::FstrBegin(current_str).spanned(self.span_since(&marker)));
+                    } else {
+                        tokens.push(
+                            Token::FstrContinue(current_str).spanned(self.span_since(&marker)),
+                        );
+                    }
+
+                    self.input.rewind(ending_marker);
+
+                    return Ok(TokenList(tokens));
+                }
+            } else {
+                for _ in 0..seen_quotes {
+                    current_str.push(ending_char);
+                }
+                seen_quotes = 0;
+                save_marker = true;
             }
 
             if self.try_parse(|x| x.parse_seq("{{")).is_ok() {
                 current_str.push('{');
-                continue;
-            }
-
-            if self.try_parse(|x| x.parse_seq("}}")).is_ok() {
+            } else if self.try_parse(|x| x.parse_seq("}}")).is_ok() {
                 current_str.push('}');
-                continue;
-            } else if self.try_parse(|x| x.parse_seq("}")).is_ok() {
+            } else if self.try_parse(|x| x.parse_char('}')).is_ok() {
                 return Err(Rich::custom(self.span_since(&marker), "unexpected '}'"));
-            }
-
-            if self.try_parse(|x| x.parse_seq("{")).is_ok() {
+            } else if self.try_parse(|x| x.parse_char('{')).is_ok() {
                 if tokens.len() == 0 {
                     tokens.push(Token::FstrBegin(current_str).spanned(self.span_since(&marker)));
                 } else {
@@ -669,7 +671,7 @@ where
                 let mut format_tokens = vec![];
                 if self.try_parse(|x| x.parse_seq("!")).is_ok() {
                     format_tokens.push(Token::Symbol("!").spanned(self.span_since(&marker)));
-                    format_tokens.extend(self.parse_fstr_inner("}", verbatim)?);
+                    format_tokens.extend(self.parse_fstr_inner('}', 1, verbatim)?);
                 }
 
                 self.parse_seq("}")?;
@@ -690,72 +692,152 @@ where
                 tokens.extend(format_tokens);
 
                 marker = self.cursor();
+            } else {
+                let next_char = if verbatim {
+                    self.next().ok_or_else(|| {
+                        Rich::custom(self.span_since(&marker), "unterminated verbatim fstring")
+                    })?
+                } else {
+                    self.parse_escaped_char()?
+                };
 
-                continue;
+                if save_marker {
+                    current_str.push(next_char);
+                }
             }
 
-            if verbatim {
-                current_str.push(self.next().ok_or_else(|| {
-                    Rich::custom(self.span_since(&marker), "unterminated verbatim fstring")
-                })?);
-            } else {
-                current_str.push(self.parse_escaped_char()?);
+            if save_marker {
+                ending_marker = self.input.save();
             }
         }
     }
 
-    fn parse_fstr(&mut self, verbatim: bool) -> TResult<'src, TokenList<'src>> {
-        if verbatim {
-            self.parse_seq("f\"\"\"")?;
-            let inner = self.parse_fstr_inner("\"\"\"", true)?;
-            self.parse_seq("\"\"\"")?;
-            return Ok(inner);
-        } else {
-            self.parse_seq("f\"")?;
-            let inner = self.parse_fstr_inner("\"", false)?;
-            self.parse_seq("\"")?;
-            return Ok(inner);
+    fn parse_regular_str(&mut self, ch: char) -> TResult<'src, Spanned<Token<'src>>> {
+        let start = self.cursor();
+        let mut quote_count = 0;
+
+        let mut verbatim = self.try_parse(|x| x.parse_char('r')).is_ok();
+
+        while self.try_parse(|x| x.parse_char(ch)).is_ok() {
+            quote_count += 1;
+        }
+
+        if quote_count == 2 {
+            return Ok(Token::Str(String::new()).spanned(self.span_since(&start)));
+        }
+
+        verbatim |= quote_count >= 3;
+
+        let mut seen_quotes = 0;
+        let mut s = String::new();
+        loop {
+            if !verbatim && self.try_parse(|x| x.parse_newline()).is_ok() {
+                return Err(Rich::custom(self.span_since(&start), "unterminated string"));
+            }
+
+            let Some(peeked) = self.peek() else {
+                return Err(Rich::custom(self.span_since(&start), "unterminated string"));
+            };
+
+            let mut push_next = false;
+            if peeked == ch {
+                seen_quotes += 1;
+
+                if seen_quotes == quote_count {
+                    self.next();
+                    return Ok(Token::Str(s).spanned(self.span_since(&start)));
+                }
+            } else {
+                for _ in 0..seen_quotes {
+                    s.push(ch);
+                }
+                seen_quotes = 0;
+                push_next = true;
+            }
+
+            let next_char = if verbatim {
+                self.next().unwrap()
+            } else {
+                self.parse_escaped_char()?
+            };
+
+            if push_next {
+                s.push(next_char);
+            }
         }
     }
 
-    fn parse_str_start(&mut self) -> TResult<'src, ()> {
+    fn parse_fstr(&mut self, ch: char) -> TResult<'src, TokenList<'src>> {
         let start = self.cursor();
+        let mut verbatim = self.try_parse(|x| x.parse_seq("r")).is_ok();
 
-        if self.try_parse(|x| x.parse_seq("f\"")).is_ok() {
-            return Ok(());
+        self.parse_seq("f")?;
+        let mut quote_count = 0;
+
+        while self.try_parse(|x| x.parse_char(ch)).is_ok() {
+            quote_count += 1;
         }
 
-        if self.try_parse(|x| x.parse_seq("\"")).is_ok() {
-            return Ok(());
+        if quote_count == 2 {
+            return Ok(TokenList(vec![
+                Token::FstrBegin(String::new()).spanned(self.span_since(&start)),
+            ]));
         }
 
-        Err(Rich::custom(
-            self.span_since(&start),
-            "expected string start",
-        ))
-    }
+        verbatim |= quote_count >= 3;
 
-    fn parse_str(&mut self) -> TResult<'src, TokenList<'src>> {
-        if self.look_ahead(|x| x.parse_seq("\"\"\"")).is_ok() {
-            let token = self.parse_verbatim_str()?;
-            return Ok(TokenList(vec![token]));
+        let inner = self.parse_fstr_inner(ch, quote_count, verbatim)?;
+
+        let start = self.cursor();
+
+        let mut close_quote_count = 0;
+        while self.try_parse(|x| x.parse_char(ch)).is_ok() {
+            close_quote_count += 1;
         }
 
-        if self.look_ahead(|x| x.parse_seq("\"")).is_ok() {
-            let token = self.parse_regular_str()?;
-            return Ok(TokenList(vec![token]));
+        if quote_count != close_quote_count {
+            return Err(Rich::custom(
+                self.span_since(&start),
+                format!(
+                    "expected {} closing quotes, found {}",
+                    quote_count, close_quote_count
+                ),
+            ));
         }
 
-        if self.look_ahead(|x| x.parse_seq("f\"\"\"")).is_ok() {
-            let tokens = self.parse_fstr(true)?;
+        return Ok(inner);
+    }
+
+    fn parse_str_start(&mut self) -> TResult<'src, ()> {
+        let start = self.cursor();
+
+        let _ = self.try_parse(|x| x.parse_ident_or_token());
+        self.parse_char('"')?;
+
+        Ok(())
+    }
+
+    fn parse_str(&mut self) -> TResult<'src, TokenList<'src>> {
+        if self.look_ahead(|x| x.parse_seq("rf\"")).is_ok() {
+            let tokens = self.parse_fstr('"')?;
             return Ok(tokens);
         }
 
         if self.look_ahead(|x| x.parse_seq("f\"")).is_ok() {
-            let tokens = self.parse_fstr(false)?;
+            let tokens = self.parse_fstr('"')?;
             return Ok(tokens);
         }
 
+        if self.look_ahead(|x| x.parse_seq("r\"")).is_ok() {
+            let token = self.parse_regular_str('"')?;
+            return Ok(TokenList(vec![token]));
+        }
+
+        if self.look_ahead(|x| x.parse_seq("\"")).is_ok() {
+            let token = self.parse_regular_str('"')?;
+            return Ok(TokenList(vec![token]));
+        }
+
         Err(Rich::custom(
             self.span_since(&self.cursor()),
             "expected string start",

{koatl-0.1.37 → koatl-0.1.38}/python/koatl/prelude/__init__.tl

@@ -43,6 +43,7 @@ Extension.method(str, "search")& (str, regex) => Pattern(regex).search(str)
 
 import koatl.std.lazy_module.LazyModule
 
+export import koatl.std.trait.*
 export Result, Ok, Err, Env, Memo, Async, AsyncMemo
 export std = LazyModule("koatl.std")
 

{koatl-0.1.37 → koatl-0.1.38}/python/koatl/runtime/__init__.py

@@ -19,7 +19,6 @@ meta_finder.install_hook()
 from .virtual import *
 from .record import *
 from .helpers import *
-from .classes import *
 
 
 def dummy(name):
@@ -52,7 +51,6 @@ __tl__ = SimpleNamespace(
     **{name: helpers.__dict__[name] for name in helpers.__all__},
     **{name: record.__dict__[name] for name in record.__all__},
     **{name: virtual.__dict__[name] for name in virtual.__all__},
-    **{name: classes.__dict__[name] for name in classes.__all__},
 )
 
 
@@ -61,5 +59,4 @@ __all__ = [
     *helpers.__all__,
     *record.__all__,
     *virtual.__all__,
-    *classes.__all__,
 ]

{koatl-0.1.37/koatl → koatl-0.1.38}/python/koatl/std/alg/base.tl

@@ -1,3 +1,5 @@
+import koatl.std.trait.Trait
+
 export Monad = class(Trait):
     """
     Abstract base class for monads.

{koatl-0.1.37/koatl → koatl-0.1.38}/python/koatl/std/iter.tl

@@ -1,7 +1,8 @@
 import itertools
 import builtins
-import .alg.(Traversable, Ok, Err, Memo, Async, AsyncMemo, Result)
 
+import koatl.std.trait.Trait
+import .alg.(Traversable, Ok, Err, Memo, Async, AsyncMemo, Result)
 
 export Iterable = class(Traversable, Trait):
     iter = Trait.abstract& self => None

koatl-0.1.37/python/koatl/runtime/classes.py → koatl-0.1.38/python/koatl/std/trait.py

@@ -40,7 +40,7 @@ class MappingMeta(type):
         return [(k, v) for k, v in inspect.getmembers(self) if not k.startswith("_")]
 
 
-# A utility base class to inherit from to enable __getitem__ method lookup on types and thus destructuring.
+# A utility base class to inherit from that implements Mapping on the type and thus destructuring.
 class Class(metaclass=MappingMeta):
     pass