Refactor into seperate modules

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

README.md

···
 ```gleam
 import gleam/io
 import stare
+import stare/function
+import stare/value
+import stare/type_
+import stare/import_
 
 pub fn main() -> Nil {
   let assert Ok(code) = stare.module(
     imports: [
-      stare.import_(
+      import_.import_(
         module: ["gleam", "io"],
         types: [],
         constructors: [],
···
       ),
     ],
     functions: [
-      stare.function(
+      function.function(
         name: "main",
         public: True,
         parameters: [],
-        return_type: Some(type_.nil()),
+        return_type: Some(type_.nil),
         statements: [
-          stare.function_call(
+          function.call(
             module: Some("io"),
             function: "println",
             arguments: [stare.value(value.string("Hello World!"))],

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/function
+import stare/import_
+import stare/internal/statement
 import stare/value
 
 @internal
 pub opaque type Module(a, b) {
-  Module(imports: List(Import), functions: List(Function(a, b)))
+  Module(
+    imports: List(import_.Import),
+    functions: List(function.Function(a, b)),
+  )
 }
 
 pub fn module(
-  imports imports: List(Import),
-  functions functions: List(Function(a, b)),
+  imports imports: List(import_.Import),
+  functions functions: List(function.Function(a, b)),
 ) -> Module(a, b) {
   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 add_ints(left left: Int, right right: Int) -> statement.Statement(a, b) {
+  statement.AddInts(value.int(left), value.int(right))
 }
 
-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:)
+pub fn add_floats(
+  left left: Float,
+  right right: Float,
+) -> statement.Statement(a, b) {
+  statement.AddFloats(value.float(left), value.float(right))
 }
 
-@internal
-pub opaque type Parameter {
-  Parameter(name: String, label: Option(String), type_: Option(type_.Type))
+pub fn value(value value: value.Value(a, b)) -> statement.Statement(a, b) {
+  statement.Raw(value)
 }
 
-pub fn parameter(
-  label label: Option(String),
-  name name: String,
-  type_ type_: Option(type_.Type),
-) -> Parameter {
-  Parameter(name:, label:, type_:)
-}
-
-pub fn generate_parameter(parameter param: Parameter) -> String {
-  case param.label {
-    option.Some(label) -> label <> " "
-    option.None -> ""
-  }
-  <> param.name
-  <> case param.type_ {
-    option.Some(type_) -> ": " <> type_.to_string(type_:)
-    option.None -> ""
-  }
-}
-
-@internal
-pub opaque type Statement(a, b) {
-  FunctionCall(
-    module: Option(String),
-    function_name: String,
-    arguments: List(Statement(a, b)),
-  )
-  LocalVariable(String)
-  Raw(value.Value(a, b))
-  AddInts(value.Value(a, b), value.Value(a, b))
-  AddFloats(value.Value(a, b), value.Value(a, b))
-}
-
-pub fn add_ints(left left: Int, right right: Int) -> Statement(a, b) {
-  AddInts(value.int(left), value.int(right))
-}
-
-pub fn add_floats(left left: Float, right right: Float) -> Statement(a, b) {
-  AddFloats(value.float(left), value.float(right))
-}
-
-pub fn value(value value: value.Value(a, b)) -> Statement(a, b) {
-  Raw(value)
-}
-
-pub fn local_variable(name name: String) -> Statement(a, b) {
-  LocalVariable(name)
-}
-
-pub fn function_call(
-  module module: Option(String),
-  function function_name: String,
-  arguments arguments: List(Statement(a, b)),
-) -> Statement(a, b) {
-  FunctionCall(module:, function_name:, arguments:)
-}
-
-@internal
-pub opaque type Function(a, b) {
-  Function(
-    name: String,
-    public: Bool,
-    params: List(Parameter),
-    type_: Option(type_.Type),
-    statements: List(Statement(a, b)),
-  )
-}
-
-pub fn function(
-  name name: String,
-  public public: Bool,
-  parameters params: List(Parameter),
-  return_type type_: Option(type_.Type),
-  statements statements: List(Statement(a, b)),
-) -> Function(a, b) {
-  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(a, b)) -> 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(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)
-    LocalVariable(string) -> string
-  }
-}
-
-pub fn generate_function(function function: Function(a, b)) -> 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_tree(
-    function.params
-    |> list.fold(string_tree.new(), fn(acc, param) {
-      string_tree.append(acc, generate_parameter(param) <> ",")
-    }),
-  )
-  |> 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 local_variable(name name: String) -> statement.Statement(a, b) {
+  statement.LocalVariable(name)
 }
 
 pub fn generate(module: Module(a, b)) -> String {
   let imports =
     module.imports
     |> list.fold(string_tree.new(), fn(acc, import_) {
-      string_tree.append(acc, generate_import(import_:) <> "\n")
+      string_tree.append(acc, import_.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.append(acc, function.generate_function(function:) <> "\n")
     })
 
   string_tree.new()

src/stare/function.gleam

···
+import gleam/list
+import gleam/option
+import gleam/string_tree
+import stare/internal/statement
+import stare/type_
+
+@internal
+pub opaque type Function(a, b) {
+  Function(
+    name: String,
+    public: Bool,
+    params: List(Parameter),
+    type_: option.Option(type_.Type),
+    statements: List(statement.Statement(a, b)),
+  )
+}
+
+@internal
+pub opaque type Parameter {
+  Parameter(
+    name: String,
+    label: option.Option(String),
+    type_: option.Option(type_.Type),
+  )
+}
+
+pub fn call(
+  module module: option.Option(String),
+  function function_name: String,
+  arguments arguments: List(statement.Statement(a, b)),
+) -> statement.Statement(a, b) {
+  statement.FunctionCall(module:, function_name:, arguments:)
+}
+
+pub fn parameter(
+  label label: option.Option(String),
+  name name: String,
+  type_ type_: option.Option(type_.Type),
+) -> Parameter {
+  Parameter(name:, label:, type_:)
+}
+
+@internal
+pub fn generate_parameter(parameter param: Parameter) -> String {
+  case param.label {
+    option.Some(label) -> label <> " "
+    option.None -> ""
+  }
+  <> param.name
+  <> case param.type_ {
+    option.Some(type_) -> ": " <> type_.to_string(type_:)
+    option.None -> ""
+  }
+}
+
+pub fn function(
+  name name: String,
+  public public: Bool,
+  parameters params: List(Parameter),
+  return_type type_: option.Option(type_.Type),
+  statements statements: List(statement.Statement(a, b)),
+) -> Function(a, b) {
+  Function(name:, public:, params:, type_:, statements:)
+}
+
+@internal
+pub fn generate_function(function function: Function(a, b)) -> 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_tree(
+    function.params
+    |> list.fold(string_tree.new(), fn(acc, param) {
+      string_tree.append(acc, generate_parameter(param) <> ",")
+    }),
+  )
+  |> 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, statement.generate_statement(statement) <> "\n")
+    }),
+  )
+  |> string_tree.append("}")
+  |> string_tree.to_string()
+}

src/stare/import_.gleam

···
+import gleam/list
+import gleam/option
+import gleam/string
+
+@internal
+pub opaque type Import {
+  Import(
+    module: List(String),
+    types: List(String),
+    constructors: List(String),
+    functions: List(String),
+    alias: option.Option(String),
+  )
+}
+
+pub fn import_(
+  module module: List(String),
+  types types: List(String),
+  constructors constructors: List(String),
+  functions functions: List(String),
+  alias alias: option.Option(String),
+) -> Import {
+  Import(module:, types:, constructors:, functions:, alias:)
+}
+
+@internal
+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
+  }
+}

src/stare/internal/statement.gleam

···
+import gleam/list
+import gleam/option
+import gleam/string_tree
+import stare/value
+
+@internal
+pub type Statement(a, b) {
+  FunctionCall(
+    module: option.Option(String),
+    function_name: String,
+    arguments: List(Statement(a, b)),
+  )
+  LocalVariable(String)
+  Raw(value.Value(a, b))
+  AddInts(value.Value(a, b), value.Value(a, b))
+  AddFloats(value.Value(a, b), value.Value(a, b))
+}
+
+@internal
+pub fn generate_statement(statement statement: Statement(a, b)) -> 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(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)
+    LocalVariable(string) -> string
+  }
+}

test/stare_test.gleam

···
 import gleam/option.{None, Some}
 import gleeunit
 import stare
+import stare/function
+import stare/import_
 import stare/type_
 import stare/value
 
···
 pub fn labelled_param_test() {
   let module =
     stare.module(imports: [], functions: [
-      stare.function(
+      function.function(
         name: "my_function",
         public: False,
         parameters: [
-          stare.parameter(label: None, name: "wibble", type_: None),
-          stare.parameter(label: None, name: "wobble", type_: Some(type_.int)),
-          stare.parameter(
+          function.parameter(label: None, name: "wibble", type_: None),
+          function.parameter(
+            label: None,
+            name: "wobble",
+            type_: Some(type_.int),
+          ),
+          function.parameter(
             label: Some("label"),
             name: "name",
             type_: Some(type_.string),
···
   let module =
     stare.module(
       imports: [
-        stare.import_(
+        import_.import_(
           module: ["gleam", "option"],
           types: [],
           constructors: ["Some"],
···
         ),
       ],
       functions: [
-        stare.function(
+        function.function(
           name: "do_thing",
           public: False,
           parameters: [
-            stare.parameter(
+            function.parameter(
               label: None,
               name: "option",
               type_: Some(type_.option(qualified: True, some: type_.string)),
···
           ],
           return_type: None,
           statements: [
-            stare.function_call(
+            function.call(
               module: Some("option"),
               function: "unwrap",
               arguments: [
···
             ),
           ],
         ),
-        stare.function(
+        function.function(
           name: "main",
           public: True,
           parameters: [],
           return_type: None,
           statements: [
-            stare.function_call(module: None, function: "do_thing", arguments: [
+            function.call(module: None, function: "do_thing", arguments: [
               stare.value(value.option(
                 qualified: False,
                 option: Some(value.string("")),
···
   let module =
     stare.module(
       imports: [
-        stare.import_(
+        import_.import_(
           module: ["gleam", "io"],
           types: [],
           constructors: [],
           functions: [],
           alias: None,
         ),
-        stare.import_(
+        import_.import_(
           module: ["gleam", "int"],
           types: [],
           constructors: [],
···
         ),
       ],
       functions: [
-        stare.function(
+        function.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)],
-                ),
-              ],
-            ),
+            function.call(module: Some("io"), function: "println", arguments: [
+              function.call(
+                module: Some("int"),
+                function: "to_string",
+                arguments: [stare.add_ints(1, 2)],
+              ),
+            ]),
           ],
         ),
       ],
···
   let module =
     stare.module(
       imports: [
-        stare.import_(
+        import_.import_(
           module: ["gleam", "io"],
           types: [],
           constructors: [],
           functions: [],
           alias: None,
         ),
-        stare.import_(
+        import_.import_(
           module: ["gleam", "float"],
           types: [],
           constructors: [],
···
         ),
       ],
       functions: [
-        stare.function(
+        function.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)],
-                ),
-              ],
-            ),
+            function.call(module: Some("io"), function: "println", arguments: [
+              function.call(
+                module: Some("float"),
+                function: "to_string",
+                arguments: [stare.add_floats(1.1, 2.2)],
+              ),
+            ]),
           ],
         ),
       ],
···
   let module =
     stare.module(
       imports: [
-        stare.import_(
+        import_.import_(
           module: ["gleam", "io"],
           types: [],
           constructors: [],
···
         ),
       ],
       functions: [
-        stare.function(
+        function.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!"))],
-            ),
+            function.call(module: Some("io"), function: "println", arguments: [
+              stare.value(value.string("Hello World!")),
+            ]),
           ],
         ),
       ],