public variable & function

crates/codegen/src/ts.rs

@@ -31,9 +31,10 @@ impl Codegen {
         macro_rules! semicolon { () => { if should_gen_semicolon { ";" } else { "" } }; }
 
         match ir {
-            IRKind::Define { name, type_hint, value, mutable } => {
+            IRKind::Define { public, name, type_hint, value, mutable } => {
                 format!(
-                    "{} v_{}: {} = {}{}\n",
+                    "{} {} v_{}: {} = {}{}\n",
+                    if *public { "export" } else { "" },
                     if *mutable { "let" } else { "const" },
                     name, 
                     type_hint,
@@ -67,14 +68,15 @@ impl Codegen {
                 }
             },
 
-            IRKind::Fun { name, return_type_hint, args, body } => {
+            IRKind::Fun { public, name, return_type_hint, args, body } => {
                 let args = args
                     .iter()
                     .map(|arg| format!("v_{}: {}", arg.0, arg.1))
                     .collect::<Vec<_>>().
                     join(", ");
                 format!(
-                    "const f_{} = ({}): {} => {};\n",
+                    "{} const f_{} = ({}): {} => {};\n",
+                    if *public { "export" } else { "" },
                     name,
                     args,
                     return_type_hint,

crates/hir/src/lib.rs

@@ -14,8 +14,21 @@ pub enum Value { Int(i64), Boolean(bool), String(String), Ident(String) }
 
 #[derive(Debug, Clone)]
 pub enum IRKind {
-    Define { name: String, type_hint: String, value: Box<Self>, mutable: bool },
+    Define {
-    Fun { name: String, return_type_hint: String, args: Vec<(String, String)>, body: Box<Self> },
+        public: bool,
+        name: String,
+        type_hint: String,
+        value: Box<Self>,
+        mutable: bool
+    },
+    Fun {
+        public: bool,
+        name: String,
+        return_type_hint: String,
+        args: Vec<(String, String)>,
+        body: Box<Self>
+    },
+
     Call { name: String, args: Vec<Self> },
     Intrinsic { name: String, args: Vec<Self> },
     Do { body: Vec<Self> },
@@ -186,12 +199,13 @@ pub fn expr_to_ir(expr: &Expr) -> (Option<IRKind>, Option<LoweringError>) {
             };
         },
 
-        Expr::Let { name, type_hint, value, mutable } => {
+        Expr::Let { public, name, type_hint, value, mutable } => {
             let value = expr_to_ir(&value.0);
             if_err_return!(value.1);
 
             let value = value.0.unwrap();
             let ir_kind = IRKind::Define {
+                public: *public,
                 name: name.clone(),
                 type_hint: gen_type_hint(type_hint),
                 value: Box::new(value),
@@ -233,7 +247,7 @@ pub fn expr_to_ir(expr: &Expr) -> (Option<IRKind>, Option<LoweringError>) {
             return (Some(ir_kind), None);
         },
 
-        Expr::Fun { name, type_hint, args, body } => {
+        Expr::Fun { public, name, type_hint, args, body } => {
             // Iterate each argument and give it a type hint
             let args = args.0.iter().map(|arg| (arg.0.0.clone(), gen_type_hint(&arg.1.0))).collect::<Vec<_>>();
 
@@ -241,7 +255,13 @@ pub fn expr_to_ir(expr: &Expr) -> (Option<IRKind>, Option<LoweringError>) {
             if_err_return!(body.1);
 
             let body = body.0.unwrap();
-            let ir_kind = IRKind::Fun { name: name.clone(), return_type_hint: gen_type_hint(type_hint), args, body: Box::new(body) };
+            let ir_kind = IRKind::Fun {
+                public: *public,
+                name: name.clone(),
+                return_type_hint: gen_type_hint(type_hint),
+                args,
+                body: Box::new(body)
+            };
             return (Some(ir_kind), None);
         },
 

crates/lexer/src/lib.rs

@@ -8,6 +8,7 @@ pub enum Token {
     KwIf, KwThen, KwElse,
     KwCase, KwOf,
     KwReturn,
+    KwPub,
 
     // Literals
     Int(i64), Boolean(bool),
@@ -42,6 +43,7 @@ impl std::fmt::Display for Token {
             Token::KwCase => write!(f, "case"),
             Token::KwOf => write!(f, "of"),
             Token::KwReturn => write!(f, "return"),
+            Token::KwPub => write!(f, "pub"),
 
             Token::Int(i) => write!(f, "{}", i),
             Token::Boolean(b) => write!(f, "{}", b),
@@ -130,6 +132,7 @@ pub fn lexer() -> impl Parser<char, Vec<(Token, Span)>, Error = Simple<char>> {
         "case" => Token::KwCase,
         "of" => Token::KwOf,
         "return" => Token::KwReturn,
+        "pub" => Token::KwPub,
         _ => Token::Identifier(s),
     });
 

crates/parser/src/lib.rs

@@ -15,12 +15,14 @@ pub enum Expr {
     Intrinsic { name: Box<Spanned<Self>>, args: Spanned<Vec<Spanned<Self>>> },
 
     Let {
+        public: bool,
         name: String,
         type_hint: String,
         value: Box<Spanned<Self>>,
         mutable: bool,
     },
     Fun {
+        public: bool,
         name: String,
         type_hint: String,
         args: Spanned<Vec<(Spanned<String>, Spanned<String>)>>,
@@ -198,16 +200,18 @@ fn expr_parser() -> impl Parser<Token, Vec<Spanned<Expr>>, Error = Simple<Token>
                 )
             });
 
-        let let_ = just(Token::KwLet)
+        let let_ = just(Token::KwPub).or_not()
-            .ignore_then(just(Token::KwMut).or_not())
+            .then_ignore(just(Token::KwLet))
+            .then(just(Token::KwMut).or_not())
             .then(identifier)
             .then_ignore(just(Token::Colon))
             .then(identifier)
             .then_ignore(just(Token::Assign))
             .then(expr.clone())
-            .map(|(((mutable, name), type_hint), value)| {
+            .map(|((((public, mutable), name), type_hint), value)| {
                 (
                     Expr::Let {
+                        public: public.is_some(),
                         name: name.0.clone(),
                         type_hint: type_hint.0,
                         value: Box::new(value.clone()),
@@ -217,8 +221,9 @@ fn expr_parser() -> impl Parser<Token, Vec<Spanned<Expr>>, Error = Simple<Token>
                 )
             });
 
-        let fun = just(Token::KwFun)
+        let fun = just(Token::KwPub).or_not()
-            .ignore_then(identifier)
+            .then_ignore(just(Token::KwFun))
+            .then(identifier)
             .then(
                 identifier
                     .then_ignore(just(Token::Colon))
@@ -233,9 +238,10 @@ fn expr_parser() -> impl Parser<Token, Vec<Spanned<Expr>>, Error = Simple<Token>
             .then(identifier)
             .then_ignore(just(Token::Assign))
             .then(expr.clone())
-            .map(|(((name, args), type_hint), body)| {
+            .map(|((((public, name), args), type_hint), body)| {
                 (
                     Expr::Fun {
+                        public: public.is_some(),
                         name: name.0.clone(),
                         type_hint: type_hint.0,
                         args: (args, name.1.clone()),

example/export.hz

@@ -0,0 +1,4 @@
+pub fun print_something: void = @emit("console.log('something')");
+
+fun main: void = do
+end;