allow for private imports

Author: kaikalii

changelog.md

@@ -11,7 +11,7 @@ This version is not yet released. If you are reading this on the website, then t
 - **Breaking Change** - Numeric subscripted [`join ⊂`](https://uiua.org/docs/join) now joins that many arrays
 - **Breaking Change** - Remove combining `e` number literals
   - It was confusing when combined with `e` scientific number notation
-- Allow for private [modules](https://uiua.org/tutorial/modules#private-scoped-modules) and [data definitions](https://uiua.org/tutorial/datadefs#visibility)
+- Allow for private [modules](https://uiua.org/tutorial/modules#private-scoped-modules), [imports](/tutorial/modules#private-imports), and [data definitions](https://uiua.org/tutorial/datadefs#visibility)
 - Add array pack syntactic sugar. This lets you write code like `[⊃(+|×)]` as `⊃[+|×]`.
 - Subscripts can now be typed with `,` instead of `__`s
 - Add numeric subscripts for [`keep ▽`](https://uiua.org/docs/keep) to keep along a number of dimensions

parser/src/ast.rs

@@ -145,6 +145,8 @@ pub struct Import {
     pub name: Option<Sp<Ident>>,
     /// The span of the ~
     pub tilde_span: CodeSpan,
+    /// Whether the import is public
+    pub public: bool,
     /// The import path
     pub path: Sp<String>,
     /// The import lines

parser/src/parse.rs

@@ -482,26 +482,6 @@ impl Parser<'_> {
             array_macro,
         })
     }
-    fn import_init(&mut self) -> Option<(Option<Sp<Ident>>, CodeSpan, Sp<String>)> {
-        let start = self.index;
-        // Name
-        let name = self.ident();
-        self.spaces();
-        // Tilde
-        let Some(tilde_span) = self.exact(Tilde.into()) else {
-            self.index = start;
-            return None;
-        };
-        self.spaces();
-        // Path
-        let Some(path) = self.next_token_map(Token::as_string) else {
-            self.index = start;
-            return None;
-        };
-        let path = path.map(Into::into);
-        self.spaces();
-        Some((name, tilde_span, path))
-    }
     fn binding(&mut self) -> Option<Binding> {
         let BindingInit {
             name,
@@ -785,7 +765,29 @@ impl Parser<'_> {
         }
     }
     fn import(&mut self) -> Option<Import> {
-        let (name, tilde_span, path) = self.import_init()?;
+        let start = self.index;
+        // Name
+        let name = self.ident();
+        self.spaces();
+        // Tilde
+        let Some((tilde_span, public)) =
+            (self.exact(Tilde.into()).map(|s| (s, true))).or_else(|| {
+                self.exact(TildeStroke)
+                    .or_else(|| self.exact(DoubleTilde.into()))
+                    .map(|s| (s, false))
+            })
+        else {
+            self.index = start;
+            return None;
+        };
+        self.spaces();
+        // Path
+        let Some(path) = self.next_token_map(Token::as_string) else {
+            self.index = start;
+            return None;
+        };
+        let path = path.map(Into::into);
+        self.spaces();
         // Items
         let mut lines: Vec<Option<ImportLine>> = Vec::new();
         let mut line: Option<ImportLine> = None;
@@ -842,6 +844,7 @@ impl Parser<'_> {
         Some(Import {
             name,
             tilde_span,
+            public,
             path,
             lines,
         })

site/src/tutorial.rs

@@ -1591,6 +1591,9 @@ fn TutorialModules() -> impl IntoView {
         <p>"To enter this arrow, you can put a "<code>"~"</code>" after a binding's normal "<code>"←"</code>" or "<code>"="</code>"."</p>
         <p>"Try formatting the following example to see how this works."</p>
         <Editor example="A = +1\nB ← +2\nC =~ +3\nD ←~ +4"/>
+        <Hd3 id="private-imports">"Private Imports"</Hd3>
+        <p>"Imports can be made private by using a "<code>"≁"</code>" instead of the first "<code>"~"</code>". "<code>"≁"</code>" formats from "<code>"~~"</code>"."</p>
+        <Editor example="# Try formatting!\n┌─╴M\n  Ex ~~ \"example\"\n└─╴\nM~Ex~Foo"/> // Should fail
         <Hd3 id="private-scoped-modules">"Private Scoped Modules"</Hd3>
         <p>"Scoped modules can be made private with special delimiters "<code>"┌╶╶"</code>" and "<code>"└╶╶"</code>". These format from the normal delimiters or "<code>"---"</code>"s followed by a "<code>"~"</code>"."</p>
         <Editor example="┌─╴A\n  ┌╶╶B\n    C ← 5\n  └╶╶\n└─╴\nA~B~C"/> // Should fail

site/text/data_defs.md

@@ -118,7 +118,7 @@ Abilities!(°⊸Con 12 °⊸Dex 16 New)
 
 ### Visibility
 
-Like bindings, data definitions can be made private with a special glyph. `≁` formats from `~~` and makes a data definition private.
+Like imports, data definitions can be made private by using `≁` instead of `~`. `≁` formats from `~~`.
 
 ```uiua should fail
 ┌─╴M

src/compile/binding.rs

@@ -543,7 +543,7 @@ impl Compiler {
             self.next_global += 1;
             let local = LocalName {
                 index: global_index,
-                public: true,
+                public: import.public,
             };
             self.asm.add_binding_at(
                 local,

src/format.rs

@@ -873,7 +873,8 @@ impl Formatter<'_> {
                     self.output.push(' ');
                     self.prev_import_function = Some(name.value.clone());
                 }
-                self.output.push_str("~ ");
+                self.output
+                    .push_str(if import.public { "~ " } else { "≁ " });
                 self.push(&import.path.span, &format!("{:?}", import.path.value));
 
                 let mut import = import.clone();