Initial Commit

Signed-off-by: Naomi Roberts <[e-mail]>

.gitignore

···
+*.beam
+*.ez
+/build
+erl_crash.dump
+.envrc
+.direnv/

.tangled/workflows/test.yaml

···
+when:
+  - event: ["push", "pull-request"]
+    branch: main
+
+engine: "nixery"
+
+steps:
+  - test:
+    command: "nix run .#test"

README.md

···
+# stare
+
+[![Package Version](https://img.shields.io/hexpm/v/stare)](https://hex.pm/packages/stare)
+[![Hex Docs](https://img.shields.io/badge/hex-docs-ffaff3)](https://hexdocs.pm/stare/)
+
+```sh
+gleam add stare@1
+```
+```gleam
+import gleam/io
+import stare
+
+pub fn main() -> Nil {
+  let assert Ok(code) = stare.module(
+    imports: [
+      stare.import_(
+        module: ["gleam", "io"],
+        types: [],
+        constructors: [],
+        functions: [],
+        alias: None,
+      ),
+    ],
+    functions: [
+      stare.function(
+        name: "main",
+        public: True,
+        parameters: [],
+        return_type: Some(type_.nil()),
+        statements: [
+          stare.function_call(
+            module: Some("io"),
+            function: "println",
+            arguments: [stare.value(value.string("Hello World!"))],
+          ),
+        ],
+      ),
+    ],
+  )
+  io.println(code)
+  // import gleam/io
+  // 
+  // pub fn main() -> Nil {
+  //  io.println("Hello World!")
+  //}
+}
+```
+
+Further documentation can be found at <https://hexdocs.pm/stare>.
+
+## Development
+
+```sh
+gleam run   # Run the project
+gleam test  # Run the tests
+```

flake.lock

···
+{
+  "nodes": {
+    "nixpkgs": {
+      "locked": {
+        "lastModified": 1757034884,
+        "narHash": "sha256-PgLSZDBEWUHpfTRfFyklmiiLBE1i1aGCtz4eRA3POao=",
+        "owner": "NixOS",
+        "repo": "nixpkgs",
+        "rev": "ca77296380960cd497a765102eeb1356eb80fed0",
+        "type": "github"
+      },
+      "original": {
+        "owner": "NixOS",
+        "ref": "nixpkgs-unstable",
+        "repo": "nixpkgs",
+        "type": "github"
+      }
+    },
+    "root": {
+      "inputs": {
+        "nixpkgs": "nixpkgs"
+      }
+    }
+  },
+  "root": "root",
+  "version": 7
+}

flake.nix

···
+{
+  inputs = {
+    nixpkgs.url = "github:NixOS/nixpkgs/nixpkgs-unstable";
+  };
+
+  outputs = {nixpkgs, ...}: let
+    lib = nixpkgs.lib;
+    supportedSystems = ["x86_64-linux" "aarch64-linux" "x86_64-darwin" "aarch64-darwin"];
+    forEachSupportedSystem = f:
+      lib.genAttrs supportedSystems (system:
+        f {
+          pkgs = import nixpkgs {inherit system;};
+        });
+  in {
+    devShells = forEachSupportedSystem ({pkgs}: {
+      default = pkgs.mkShell {
+        packages = with pkgs; [
+          gleam
+          erlang_28
+          beam28Packages.rebar3
+        ];
+      };
+    });
+    apps = forEachSupportedSystem ({pkgs}: let
+      runtimeInputs = with pkgs; [
+        gleam
+        erlang_28
+        beam28Packages.rebar3
+      ];
+    in {
+      test = {
+        type = "app";
+        program = "${(pkgs.writeShellApplication {
+          inherit runtimeInputs;
+          name = "test";
+          text = ''
+            ${pkgs.gleam}/bin/gleam test
+          '';
+        })}/bin/test";
+      };
+    });
+  };
+}

gleam.toml

···
+name = "stare"
+version = "1.0.0"
+
+# Fill out these fields if you intend to generate HTML documentation or publish
+# your project to the Hex package manager.
+#
+# description = ""
+# licences = ["Apache-2.0"]
+# repository = { type = "github", user = "", repo = "" }
+# links = [{ title = "Website", href = "" }]
+#
+# For a full reference of all the available options, you can have a look at
+# https://gleam.run/writing-gleam/gleam-toml/.
+
+[dependencies]
+gleam_stdlib = ">= 0.44.0 and < 2.0.0"
+shellout = ">= 1.7.0 and < 2.0.0"
+simplifile = ">= 2.3.0 and < 3.0.0"
+
+[dev-dependencies]
+gleeunit = ">= 1.0.0 and < 2.0.0"

manifest.toml

···
+# This file was generated by Gleam
+# You typically do not need to edit this file
+
+packages = [
+  { name = "filepath", version = "1.1.2", build_tools = ["gleam"], requirements = ["gleam_stdlib"], otp_app = "filepath", source = "hex", outer_checksum = "B06A9AF0BF10E51401D64B98E4B627F1D2E48C154967DA7AF4D0914780A6D40A" },
+  { name = "gleam_stdlib", version = "0.63.0", build_tools = ["gleam"], requirements = [], otp_app = "gleam_stdlib", source = "hex", outer_checksum = "5E216C7D5E8BE22359C9D7DAA2CFBD66039BC12565542F34CD033C5BB57071ED" },
+  { name = "gleeunit", version = "1.6.1", build_tools = ["gleam"], requirements = ["gleam_stdlib"], otp_app = "gleeunit", source = "hex", outer_checksum = "FDC68A8C492B1E9B429249062CD9BAC9B5538C6FBF584817205D0998C42E1DAC" },
+  { name = "shellout", version = "1.7.0", build_tools = ["gleam"], requirements = ["gleam_stdlib"], otp_app = "shellout", source = "hex", outer_checksum = "1BDC03438FEB97A6AF3E396F4ABEB32BECF20DF2452EC9A8C0ACEB7BDDF70B14" },
+  { name = "simplifile", version = "2.3.0", build_tools = ["gleam"], requirements = ["filepath", "gleam_stdlib"], otp_app = "simplifile", source = "hex", outer_checksum = "0A868DAC6063D9E983477981839810DC2E553285AB4588B87E3E9C96A7FB4CB4" },
+]
+
+[requirements]
+gleam_stdlib = { version = ">= 0.44.0 and < 2.0.0" }
+gleeunit = { version = ">= 1.0.0 and < 2.0.0" }
+shellout = { version = ">= 1.7.0 and < 2.0.0" }
+simplifile = { version = ">= 2.3.0 and < 3.0.0" }

src/stare.gleam

···
+import gleam/list
+import gleam/option.{type Option}
+import gleam/result
+import gleam/string
+import gleam/string_tree
+import shellout
+import simplifile
+import stare/type_
+import stare/value
+
+@internal
+pub opaque type Module {
+  Module(imports: List(Import), functions: List(Function))
+}
+
+pub fn module(
+  imports imports: List(Import),
+  functions functions: List(Function),
+) -> Module {
+  Module(imports:, functions:)
+}
+
+@internal
+pub opaque type Import {
+  Import(
+    module: List(String),
+    types: List(String),
+    constructors: List(String),
+    functions: List(String),
+    alias: Option(String),
+  )
+}
+
+pub fn import_(
+  module module: List(String),
+  types types: List(String),
+  constructors constructors: List(String),
+  functions functions: List(String),
+  alias alias: Option(String),
+) -> Import {
+  Import(module:, types:, constructors:, functions:, alias:)
+}
+
+@internal
+pub opaque type Parameter {
+  Parameter(name: String, label: Option(String), type_: Option(type_.Type))
+}
+
+pub fn parameter(
+  label label: Option(String),
+  name name: String,
+  type_ type_: Option(type_.Type),
+) -> Parameter {
+  Parameter(name:, label:, type_:)
+}
+
+@internal
+pub opaque type Statement {
+  FunctionCall(
+    module: Option(String),
+    function_name: String,
+    arguments: List(Statement),
+  )
+  Raw(value.Value)
+  AddInts(value.Value, value.Value)
+  AddFloats(value.Value, value.Value)
+}
+
+pub fn add_ints(left left: Int, right right: Int) -> Statement {
+  AddInts(value.int(left), value.int(right))
+}
+
+pub fn add_floats(left left: Float, right right: Float) -> Statement {
+  AddFloats(value.float(left), value.float(right))
+}
+
+pub fn value(value value: value.Value) -> Statement {
+  Raw(value)
+}
+
+pub fn function_call(
+  module module: Option(String),
+  function function_name: String,
+  arguments arguments: List(Statement),
+) -> Statement {
+  FunctionCall(module:, function_name:, arguments:)
+}
+
+@internal
+pub opaque type Function {
+  Function(
+    name: String,
+    public: Bool,
+    params: List(Parameter),
+    type_: Option(type_.Type),
+    statements: List(Statement),
+  )
+}
+
+pub fn function(
+  name name: String,
+  public public: Bool,
+  parameters params: List(Parameter),
+  return_type type_: Option(type_.Type),
+  statements statements: List(Statement),
+) -> Function {
+  Function(name:, public:, params:, type_:, statements:)
+}
+
+pub fn generate_import(import_ import_: Import) -> String {
+  let Import(module:, types:, constructors:, functions:, alias:) = import_
+  let i =
+    "import "
+    <> list.fold(module, "", fn(acc, part) { acc <> part <> "/" })
+    |> string.drop_end(1)
+
+  let i = case types, constructors, functions {
+    [], [], [] -> i
+    _, _, _ -> {
+      i
+      <> ".{"
+      <> list.fold(types, "", fn(acc, type_) { acc <> "type " <> type_ <> "," })
+      <> list.fold(constructors, "", fn(acc, constructor) {
+        acc <> constructor <> ","
+      })
+      <> list.fold(functions, "", fn(acc, function) { acc <> function <> "," })
+      <> "}"
+    }
+  }
+  case alias {
+    option.None -> i
+    option.Some(alias) -> i <> " as " <> alias
+  }
+}
+
+pub fn generate_statement(statement statement: Statement) -> String {
+  case statement {
+    FunctionCall(module:, function_name:, arguments: _) -> {
+      string_tree.new()
+      |> string_tree.append(case module {
+        option.None -> ""
+        option.Some(module) -> module <> "."
+      })
+      |> string_tree.append(function_name)
+      |> string_tree.append("(")
+      |> string_tree.append(
+        list.fold(statement.arguments, "", fn(acc, arg) {
+          acc <> generate_statement(arg) <> ","
+        }),
+      )
+      |> string_tree.append(")")
+      |> string_tree.to_string()
+    }
+    Raw(value) -> value.to_string(value)
+    AddInts(left, right) ->
+      value.to_string(left) <> "+" <> value.to_string(right)
+    AddFloats(left, right) ->
+      value.to_string(left) <> "+." <> value.to_string(right)
+  }
+}
+
+pub fn generate_function(function function: Function) -> String {
+  string_tree.new()
+  |> string_tree.append(case function.public {
+    False -> ""
+    True -> "pub "
+  })
+  |> string_tree.append("fn ")
+  |> string_tree.append(function.name <> "(")
+  |> string_tree.append(") ")
+  |> string_tree.append(case function.type_ {
+    option.None -> ""
+    option.Some(type_) -> "-> " <> type_.to_string(type_:) <> " "
+  })
+  |> string_tree.append("{\n")
+  |> string_tree.append_tree(
+    function.statements
+    |> list.fold(string_tree.new(), fn(acc, statement) {
+      string_tree.append(acc, generate_statement(statement) <> "\n")
+    }),
+  )
+  |> string_tree.append("}")
+  |> string_tree.to_string()
+}
+
+pub fn generate(module: Module) -> String {
+  let imports =
+    module.imports
+    |> list.fold(string_tree.new(), fn(acc, import_) {
+      string_tree.append(acc, generate_import(import_:) <> "\n")
+    })
+
+  let functions =
+    module.functions
+    |> list.fold(string_tree.new(), fn(acc, function) {
+      string_tree.append(acc, generate_function(function:) <> "\n")
+    })
+
+  string_tree.new()
+  |> string_tree.append_tree(imports)
+  |> string_tree.append("\n")
+  |> string_tree.append_tree(functions)
+  |> string_tree.to_string()
+}
+
+pub fn format(code code: String) -> Result(String, Nil) {
+  use _ <- result.try(
+    simplifile.create_directory_all("./build/tmp/")
+    |> result.replace_error(Nil),
+  )
+  use _ <- result.try(
+    simplifile.write(to: "./build/tmp/format.gleam", contents: code)
+    |> result.replace_error(Nil),
+  )
+  use _ <- result.try(
+    shellout.command(
+      run: "gleam",
+      with: ["format", "./build/tmp/format.gleam"],
+      in: ".",
+      opt: [],
+    )
+    |> result.replace_error(Nil),
+  )
+  use code <- result.try(
+    simplifile.read(from: "./build/tmp/format.gleam")
+    |> result.replace_error(Nil),
+  )
+  use _ <- result.try(
+    simplifile.delete("./build/tmp/format.gleam")
+    |> result.replace_error(Nil),
+  )
+  Ok(code)
+}

src/stare/type_.gleam

···
+@internal
+pub type Constructor
+
+@internal
+pub opaque type Type {
+  CustomType(
+    name: String,
+    public: Bool,
+    opaque_: Bool,
+    constructors: List(Constructor),
+  )
+  NilType
+  StringType
+}
+
+@internal
+pub fn to_string(type_ type_: Type) -> String {
+  case type_ {
+    CustomType(name:, public: _, opaque_: _, constructors: _) -> name
+    NilType -> "Nil"
+    StringType -> "String"
+  }
+}
+
+pub fn nil() -> Type {
+  NilType
+}
+
+pub fn string() -> Type {
+  StringType
+}
+
+pub fn custom(
+  name name: String,
+  public public: Bool,
+  opaque_ opaque_: Bool,
+  constructors constructors: List(Constructor),
+) -> Type {
+  CustomType(name:, public:, opaque_:, constructors:)
+}

src/stare/value.gleam

···
+import gleam/float
+import gleam/int
+
+@internal
+pub opaque type Value {
+  NilValue
+  StringValue(String)
+  IntValue(Int)
+  FloatValue(Float)
+}
+
+@internal
+pub fn to_string(value value: Value) -> String {
+  case value {
+    NilValue -> "Nil"
+    StringValue(v) -> "\"" <> v <> "\""
+    IntValue(v) -> int.to_string(v)
+    FloatValue(v) -> float.to_string(v)
+  }
+}
+
+pub fn nil() -> Value {
+  NilValue
+}
+
+pub fn string(string string: String) -> Value {
+  StringValue(string)
+}
+
+pub fn int(int int: Int) -> Value {
+  IntValue(int)
+}
+
+pub fn float(float float: Float) -> Value {
+  FloatValue(float)
+}

test/stare_test.gleam

···
+import gleam/option.{None, Some}
+import gleeunit
+import stare
+import stare/type_
+import stare/value
+
+pub fn main() -> Nil {
+  gleeunit.main()
+}
+
+pub fn integer_addition_test() {
+  let module =
+    stare.module(
+      imports: [
+        stare.import_(
+          module: ["gleam", "io"],
+          types: [],
+          constructors: [],
+          functions: [],
+          alias: None,
+        ),
+        stare.import_(
+          module: ["gleam", "int"],
+          types: [],
+          constructors: [],
+          functions: [],
+          alias: None,
+        ),
+      ],
+      functions: [
+        stare.function(
+          name: "main",
+          public: True,
+          parameters: [],
+          return_type: None,
+          statements: [
+            stare.function_call(
+              module: Some("io"),
+              function: "println",
+              arguments: [
+                stare.function_call(
+                  module: Some("int"),
+                  function: "to_string",
+                  arguments: [stare.add_ints(1, 2)],
+                ),
+              ],
+            ),
+          ],
+        ),
+      ],
+    )
+  let assert Ok(code) =
+    module
+    |> stare.generate()
+    |> stare.format()
+
+  let file =
+    "import gleam/int
+import gleam/io
+
+pub fn main() {
+  io.println(int.to_string(1 + 2))
+}
+"
+
+  assert file == code
+}
+
+pub fn float_addition_test() {
+  let module =
+    stare.module(
+      imports: [
+        stare.import_(
+          module: ["gleam", "io"],
+          types: [],
+          constructors: [],
+          functions: [],
+          alias: None,
+        ),
+        stare.import_(
+          module: ["gleam", "float"],
+          types: [],
+          constructors: [],
+          functions: [],
+          alias: None,
+        ),
+      ],
+      functions: [
+        stare.function(
+          name: "main",
+          public: True,
+          parameters: [],
+          return_type: None,
+          statements: [
+            stare.function_call(
+              module: Some("io"),
+              function: "println",
+              arguments: [
+                stare.function_call(
+                  module: Some("float"),
+                  function: "to_string",
+                  arguments: [stare.add_floats(1.1, 2.2)],
+                ),
+              ],
+            ),
+          ],
+        ),
+      ],
+    )
+  let assert Ok(code) =
+    module
+    |> stare.generate()
+    |> stare.format()
+
+  let file =
+    "import gleam/float
+import gleam/io
+
+pub fn main() {
+  io.println(float.to_string(1.1 +. 2.2))
+}
+"
+
+  assert file == code
+}
+
+pub fn generate_hello_world_test() {
+  let module =
+    stare.module(
+      imports: [
+        stare.import_(
+          module: ["gleam", "io"],
+          types: [],
+          constructors: [],
+          functions: [],
+          alias: None,
+        ),
+      ],
+      functions: [
+        stare.function(
+          name: "main",
+          public: True,
+          parameters: [],
+          return_type: Some(type_.nil()),
+          statements: [
+            stare.function_call(
+              module: Some("io"),
+              function: "println",
+              arguments: [stare.value(value.string("Hello World!"))],
+            ),
+          ],
+        ),
+      ],
+    )
+
+  let assert Ok(code) =
+    module
+    |> stare.generate()
+    |> stare.format()
+
+  let file =
+    "import gleam/io
+
+pub fn main() -> Nil {
+  io.println(\"Hello World!\")
+}
+"
+
+  assert file == code
+}