All types/values from prelude and stdlib

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

birdie_snapshots/imported_type.accepted

···
+---
+version: 1.4.0
+title: Imported type
+file: ./test/stare_test.gleam
+test_name: use_imported_types_test
+---
+import gleam/option.{Some}
+
+fn do_thing(option: option.Option(String)) {
+  option.unwrap(option, "unwrapped")
+}
+
+pub fn main() {
+  do_thing(Some(""))
+}
+

birdie_snapshots/mixed_parameters.accepted

···
+---
+version: 1.4.0
+title: Mixed Parameters
+file: ./test/stare_test.gleam
+test_name: labelled_param_test
+---
+fn my_function(wibble, wobble: Int, label name: String) {
+  "Testing!"
+}
+

src/stare.gleam

···
 import stare/value
 
 @internal
-pub opaque type Module {
-  Module(imports: List(Import), functions: List(Function))
+pub opaque type Module(a, b) {
+  Module(imports: List(Import), functions: List(Function(a, b)))
 }
 
 pub fn module(
   imports imports: List(Import),
-  functions functions: List(Function),
-) -> Module {
+  functions functions: List(Function(a, b)),
+) -> Module(a, b) {
   Module(imports:, functions:)
 }
 
···
   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 {
+pub opaque type Statement(a, b) {
   FunctionCall(
     module: Option(String),
     function_name: String,
-    arguments: List(Statement),
+    arguments: List(Statement(a, b)),
   )
-  Raw(value.Value)
-  AddInts(value.Value, value.Value)
-  AddFloats(value.Value, value.Value)
+  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 {
+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 {
+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) -> Statement {
+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),
-) -> Statement {
+  arguments arguments: List(Statement(a, b)),
+) -> Statement(a, b) {
   FunctionCall(module:, function_name:, arguments:)
 }
 
 @internal
-pub opaque type Function {
+pub opaque type Function(a, b) {
   Function(
     name: String,
     public: Bool,
     params: List(Parameter),
     type_: Option(type_.Type),
-    statements: List(Statement),
+    statements: List(Statement(a, b)),
   )
 }
 
···
   public public: Bool,
   parameters params: List(Parameter),
   return_type type_: Option(type_.Type),
-  statements statements: List(Statement),
-) -> Function {
+  statements statements: List(Statement(a, b)),
+) -> Function(a, b) {
   Function(name:, public:, params:, type_:, statements:)
 }
 
···
   }
 }
 
-pub fn generate_statement(statement statement: Statement) -> String {
+pub fn generate_statement(statement statement: Statement(a, b)) -> String {
   case statement {
-    FunctionCall(module:, function_name:, arguments: _) -> {
+    FunctionCall(module:, function_name:, arguments:) -> {
       string_tree.new()
       |> string_tree.append(case module {
         option.None -> ""
···
       |> string_tree.append(function_name)
       |> string_tree.append("(")
       |> string_tree.append(
-        list.fold(statement.arguments, "", fn(acc, arg) {
+        list.fold(arguments, "", fn(acc, arg) {
           acc <> generate_statement(arg) <> ","
         }),
       )
···
       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) -> String {
+pub fn generate_function(function function: Function(a, b)) -> String {
   string_tree.new()
   |> string_tree.append(case function.public {
     False -> ""
···
   })
   |> 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 -> ""
···
   |> string_tree.to_string()
 }
 
-pub fn generate(module: Module) -> String {
+pub fn generate(module: Module(a, b)) -> String {
   let imports =
     module.imports
     |> list.fold(string_tree.new(), fn(acc, import_) {

src/stare/type_.gleam

···
+import gleam/list
+
 @internal
 pub type Constructor
 
···
     opaque_: Bool,
     constructors: List(Constructor),
   )
+  GenericType(name: String)
   NilType
   StringType
+  IntType
+  FloatType
+  BoolType
+  ListType
+  BitArrayType
+  StringTreeType(qualified: Bool)
+  BytesTreeType(qualified: Bool)
+  DictType(qualified: Bool, key: Type, value: Type)
+  DynamicType(qualified: Bool, decode: Bool)
+  DecoderType(qualified: Bool, type_: Type)
+  DecodeErrorType(qualified: Bool)
+  ContinueOrStopType(qualified: Bool, type_: Type)
+  OptionType(qualified: Bool, some: Type)
+  OrderType(qualified: Bool)
+  TupleType(items: List(Type))
+  ResultType(ok: Type, error: Type)
+  SetType(qualified: Bool, type_: Type)
+  UriType(qualified: Bool)
 }
 
 @internal
 pub fn to_string(type_ type_: Type) -> String {
+  let qual = fn(q, x, y) {
+    case q {
+      True -> x
+      False -> y
+    }
+  }
+
   case type_ {
     CustomType(name:, public: _, opaque_: _, constructors: _) -> name
     NilType -> "Nil"
     StringType -> "String"
+    BitArrayType -> "BitArray"
+    BoolType -> "Bool"
+    BytesTreeType(qualified:) ->
+      qual(qualified, "bytes_tree.BytesTree", "BytesTree")
+    ContinueOrStopType(qualified:, type_:) ->
+      qual(qualified, "list.ContinueOrStop", "ContinueOrStop")
+      <> "("
+      <> to_string(type_)
+      <> ")"
+    DecodeErrorType(qualified:) ->
+      qual(qualified, "decode.DecodeError", "DecodeError")
+    DecoderType(qualified:, type_:) ->
+      qual(qualified, "decode.Decoder", "Decoder")
+      <> "("
+      <> to_string(type_)
+      <> ")"
+    DictType(qualified:, key:, value:) ->
+      qual(qualified, "dict.Dict", "Dict")
+      <> "("
+      <> to_string(key)
+      <> ","
+      <> to_string(value)
+      <> ")"
+    DynamicType(qualified:, decode:) ->
+      qual(
+        qualified,
+        qual(decode, "decode.Dynamic", "dynamic.Dynamic"),
+        "Dynamic",
+      )
+    FloatType -> "Float"
+    IntType -> "Int"
+    ListType -> "List"
+    OptionType(qualified:, some:) ->
+      qual(qualified, "option.Option", "Option")
+      <> "("
+      <> to_string(some)
+      <> ")"
+    OrderType(qualified:) -> qual(qualified, "order.Order", "Order")
+    ResultType(ok:, error:) ->
+      "Result" <> "(" <> to_string(ok) <> "," <> to_string(error) <> ")"
+    SetType(qualified:, type_:) ->
+      qual(qualified, "set.Set", "Set") <> "(" <> to_string(type_) <> ")"
+    StringTreeType(qualified:) ->
+      qual(qualified, "string_tree.StringTree", "StringTree")
+    TupleType(items:) ->
+      "#("
+      <> list.fold(items, "", fn(acc, item) { acc <> to_string(item) <> "," })
+      <> ")"
+    UriType(qualified:) -> qual(qualified, "uri.Uri", "Uri")
+    GenericType(name:) -> name
   }
 }
 
-pub fn nil() -> Type {
-  NilType
-}
+pub const nil: Type = NilType
 
-pub fn string() -> Type {
-  StringType
-}
+pub const string: Type = StringType
+
+pub const int: Type = IntType
+
+pub const float: Type = FloatType
+
+pub const bool: Type = BoolType
+
+pub const list: Type = ListType
+
+pub const bit_array: Type = BitArrayType
 
 pub fn custom(
   name name: String,
···
 ) -> Type {
   CustomType(name:, public:, opaque_:, constructors:)
 }
+
+pub fn string_tree(qualified qualified: Bool) -> Type {
+  StringTreeType(qualified:)
+}
+
+pub fn bytes_tree(qualified qualified: Bool) -> Type {
+  BytesTreeType(qualified:)
+}
+
+pub fn dict(qualified qualified: Bool, key key: Type, value value: Type) -> Type {
+  DictType(qualified:, key:, value:)
+}
+
+pub fn dynamic(qualified qualified: Bool) -> Type {
+  DynamicType(qualified:, decode: False)
+}
+
+pub fn decode_dynamic(qualified qualified: Bool) -> Type {
+  DynamicType(qualified:, decode: True)
+}
+
+pub fn decoder(qualified qualified: Bool, type_ type_: Type) -> Type {
+  DecoderType(qualified:, type_:)
+}
+
+pub fn decode_error(qualified qualified: Bool) -> Type {
+  DecodeErrorType(qualified)
+}
+
+pub fn continue_or_stop(qualified qualified: Bool, type_ type_: Type) -> Type {
+  ContinueOrStopType(qualified:, type_:)
+}
+
+pub fn option(qualified qualified: Bool, some some: Type) -> Type {
+  OptionType(qualified:, some:)
+}
+
+pub fn order(qualified qualified: Bool) -> Type {
+  OrderType(qualified:)
+}
+
+pub fn tuple(items items: List(Type)) -> Type {
+  TupleType(items:)
+}
+
+pub fn pair(left left: Type, right right: Type) -> Type {
+  TupleType([left, right])
+}
+
+pub fn result(ok ok: Type, error error: Type) -> Type {
+  ResultType(ok:, error:)
+}
+
+pub fn set(qualified qualified: Bool, type_ type_: Type) -> Type {
+  SetType(qualified:, type_:)
+}
+
+pub fn uri(qualified qualified: Bool) -> Type {
+  UriType(qualified:)
+}
+
+pub fn generic(name name: String) -> Type {
+  GenericType(name:)
+}

src/stare/value.gleam

···
+import gleam/bit_array
+import gleam/bool
+import gleam/dynamic/decode
 import gleam/float
 import gleam/int
+import gleam/list
+import gleam/option
+import gleam/order
+import gleam/uri
 
 @internal
-pub opaque type Value {
+pub opaque type Value(a, b) {
+  // CustomValue
   NilValue
-  StringValue(String)
-  IntValue(Int)
-  FloatValue(Float)
+  StringValue(string: String)
+  IntValue(int: Int)
+  FloatValue(float: Float)
+  BoolValue(bool: Bool)
+  ListValue(list: List(Value(a, b)))
+  BitArrayValue(bit_array: BitArray)
+  DecodeErrorValue(qualified: Bool, decode_error: decode.DecodeError)
+  ContinueOrStopValue(qualified: Bool, cos: list.ContinueOrStop(Value(a, b)))
+  OptionValue(qualified: Bool, option: option.Option(Value(a, b)))
+  OrderValue(qualified: Bool, order: order.Order)
+  TupleValue(items: List(Value(a, b)))
+  ResultValue(result: Result(Value(a, b), Value(a, b)))
+  UriValue(qualified: Bool, uri: uri.Uri)
 }
 
 @internal
-pub fn to_string(value value: Value) -> String {
+pub fn to_string(value value: Value(a, b)) -> String {
   case value {
     NilValue -> "Nil"
     StringValue(v) -> "\"" <> v <> "\""
     IntValue(v) -> int.to_string(v)
     FloatValue(v) -> float.to_string(v)
+    BitArrayValue(bit_array:) -> bit_array.inspect(bit_array)
+    BoolValue(bool:) -> bool.to_string(bool)
+    ContinueOrStopValue(qualified:, cos:) -> {
+      case qualified {
+        True -> "list."
+        _ -> ""
+      }
+      <> case cos {
+        list.Continue(value) -> "Continue(" <> to_string(value:) <> ")"
+        list.Stop(value) -> "Stop(" <> to_string(value:) <> ")"
+      }
+    }
+    DecodeErrorValue(qualified:, decode_error:) ->
+      case qualified {
+        True -> "decode."
+        False -> ""
+      }
+      <> "DecodeError(expected: "
+      <> to_string(string(decode_error.expected))
+      <> ", "
+      <> "found: "
+      <> to_string(string(decode_error.found))
+      <> ", "
+      <> "path: "
+      <> to_string(list(decode_error.path |> list.map(string)))
+    ListValue(list:) ->
+      "["
+      <> list.fold(list, "", fn(acc, item) { acc <> to_string(item) <> "," })
+      <> "]"
+    OptionValue(qualified:, option:) ->
+      case qualified {
+        True -> "option."
+        _ -> ""
+      }
+      <> case option {
+        option.None -> "None"
+        option.Some(value) -> "Some(" <> to_string(value:) <> ")"
+      }
+    OrderValue(qualified:, order:) ->
+      case qualified {
+        True -> "order."
+        False -> ""
+      }
+      <> case order {
+        order.Eq -> "Eq"
+        order.Gt -> "Gt"
+        order.Lt -> "Lt"
+      }
+    ResultValue(result:) ->
+      case result {
+        Ok(value) -> "Ok(" <> to_string(value) <> ")"
+        Error(value) -> "Error(" <> to_string(value) <> ")"
+      }
+    TupleValue(items:) ->
+      "#("
+      <> list.fold(items, "", fn(acc, item) { acc <> to_string(item) <> "," })
+      <> ")"
+    UriValue(qualified:, uri:) ->
+      case qualified {
+        True -> "uri."
+        False -> ""
+      }
+      <> "Uri("
+      <> "scheme: "
+      <> to_string(option(qualified, uri.scheme |> option.map(string)))
+      <> ","
+      <> "userinfo: "
+      <> to_string(option(qualified, uri.userinfo |> option.map(string)))
+      <> ","
+      <> "host: "
+      <> to_string(option(qualified, uri.host |> option.map(string)))
+      <> ","
+      <> "port: "
+      <> to_string(option(qualified, uri.port |> option.map(int)))
+      <> ","
+      <> "path: "
+      <> to_string(string(uri.path))
+      <> ","
+      <> "query: "
+      <> to_string(option(qualified, uri.query |> option.map(string)))
+      <> ","
+      <> "fragment: "
+      <> to_string(option(qualified, uri.fragment |> option.map(string)))
+      <> ")"
   }
 }
 
-pub fn nil() -> Value {
+pub fn nil() -> Value(a, b) {
   NilValue
 }
 
-pub fn string(string string: String) -> Value {
-  StringValue(string)
+pub fn string(string string: String) -> Value(a, b) {
+  StringValue(string:)
+}
+
+pub fn int(int int: Int) -> Value(a, b) {
+  IntValue(int:)
+}
+
+pub fn float(float float: Float) -> Value(a, b) {
+  FloatValue(float:)
+}
+
+pub fn bool(bool bool: Bool) -> Value(a, b) {
+  BoolValue(bool:)
+}
+
+pub fn list(list list: List(Value(a, b))) -> Value(a, b) {
+  ListValue(list:)
+}
+
+pub fn bit_array(bit_array bit_array: BitArray) -> Value(a, b) {
+  BitArrayValue(bit_array:)
 }
 
-pub fn int(int int: Int) -> Value {
-  IntValue(int)
+pub fn decode_error(
+  qualified qualified: Bool,
+  decode_error decode_error: decode.DecodeError,
+) -> Value(a, b) {
+  DecodeErrorValue(qualified:, decode_error:)
 }
 
-pub fn float(float float: Float) -> Value {
-  FloatValue(float)
+pub fn continue_or_stop(
+  qualified qualified: Bool,
+  continue_or_stop cos: list.ContinueOrStop(Value(a, b)),
+) -> Value(a, b) {
+  ContinueOrStopValue(qualified:, cos:)
+}
+
+pub fn option(
+  qualified qualified: Bool,
+  option option: option.Option(Value(a, b)),
+) -> Value(a, b) {
+  OptionValue(qualified:, option:)
+}
+
+pub fn order(qualified qualified: Bool, order order: order.Order) -> Value(a, b) {
+  OrderValue(qualified:, order:)
+}
+
+pub fn tuple(items items: List(Value(a, b))) -> Value(a, b) {
+  TupleValue(items:)
+}
+
+pub fn pair(left left: Value(a, b), right right: Value(a, b)) -> Value(a, b) {
+  TupleValue([left, right])
+}
+
+pub fn result(result result: Result(Value(a, b), Value(a, b))) -> Value(a, b) {
+  ResultValue(result:)
+}
+
+pub fn uri(qualified qualified: Bool, uri uri: uri.Uri) -> Value(a, b) {
+  UriValue(qualified:, uri:)
 }

test/stare_test.gleam

···
   gleeunit.main()
 }
 
+pub fn labelled_param_test() {
+  let module =
+    stare.module(imports: [], functions: [
+      stare.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(
+            label: Some("label"),
+            name: "name",
+            type_: Some(type_.string),
+          ),
+        ],
+        return_type: None,
+        statements: [stare.value(value.string("Testing!"))],
+      ),
+    ])
+
+  module
+  |> stare.generate()
+  |> stare.format()
+  |> assert_ok()
+  |> birdie.snap("Mixed Parameters")
+}
+
+pub fn use_imported_types_test() {
+  let module =
+    stare.module(
+      imports: [
+        stare.import_(
+          module: ["gleam", "option"],
+          types: [],
+          constructors: ["Some"],
+          functions: [],
+          alias: None,
+        ),
+      ],
+      functions: [
+        stare.function(
+          name: "do_thing",
+          public: False,
+          parameters: [
+            stare.parameter(
+              label: None,
+              name: "option",
+              type_: Some(type_.option(qualified: True, some: type_.string)),
+            ),
+          ],
+          return_type: None,
+          statements: [
+            stare.function_call(
+              module: Some("option"),
+              function: "unwrap",
+              arguments: [
+                stare.local_variable("option"),
+                stare.value(value.string("unwrapped")),
+              ],
+            ),
+          ],
+        ),
+        stare.function(
+          name: "main",
+          public: True,
+          parameters: [],
+          return_type: None,
+          statements: [
+            stare.function_call(module: None, function: "do_thing", arguments: [
+              stare.value(value.option(
+                qualified: False,
+                option: Some(value.string("")),
+              )),
+            ]),
+          ],
+        ),
+      ],
+    )
+
+  module
+  |> stare.generate()
+  |> stare.format()
+  |> assert_ok()
+  |> birdie.snap("Imported type")
+}
+
 pub fn integer_addition_test() {
   let module =
     stare.module(
···
           name: "main",
           public: True,
           parameters: [],
-          return_type: Some(type_.nil()),
+          return_type: Some(type_.nil),
           statements: [
             stare.function_call(
               module: Some("io"),