Support record update and more flexible calling.

Author: dusty-phillips

README.md

@@ -47,7 +47,7 @@ PRs are welcome.
 
 ### TODO
 
-- flesh out this list
+- custom types with only one variant should not build a container class
 - custom types with no fields are probably not working
 - custom types with unlabelled fields are probably not working
 - most expressions aren't implemented yet
@@ -62,3 +62,4 @@ PRs are welcome.
 - eliminate all todos in source code
 - panic should probably raise a custom/stdlib exception
 - generate **main** if a module has a main function
+- flesh out this list

src/generator.gleam

@@ -50,6 +50,20 @@ fn generate_binop(
   |> string_builder.append_builder(generate_expression(right))
 }
 
+fn generate_record_update_fields(
+  field: python.Field(python.Expression),
+) -> StringBuilder {
+  case field {
+    python.UnlabelledField(_) ->
+      panic("Unlabeled fields are not expected on record updates")
+    python.LabelledField(label, expression) ->
+      string_builder.new()
+      |> string_builder.append(label)
+      |> string_builder.append("=")
+      |> string_builder.append_builder(generate_expression(expression))
+  }
+}
+
 fn generate_expression(expression: python.Expression) {
   case expression {
     python.String(string) -> string_builder.from_strings(["\"", string, "\""])
@@ -84,9 +98,20 @@ fn generate_expression(expression: python.Expression) {
       generate_expression(expression)
       |> string_builder.append(".")
       |> string_builder.append(label)
-    python.Call(function_name, arguments) ->
+    python.RecordUpdate(record, fields) ->
+      string_builder.new()
+      |> string_builder.append("dataclasses.replace(")
+      |> string_builder.append_builder(generate_expression(record))
+      |> string_builder.append(", ")
+      |> string_builder.append_builder(generate_plural(
+        fields,
+        generate_record_update_fields,
+        ", ",
+      ))
+      |> string_builder.append(")")
+    python.Call(function, arguments) ->
       string_builder.new()
-      |> string_builder.append(function_name)
+      |> string_builder.append_builder(generate_expression(function))
       |> string_builder.append("(")
       |> string_builder.append_builder(
         arguments

src/python.gleam

@@ -43,13 +43,8 @@ pub type Expression {
   Todo(Expression)
   TupleIndex(tuple: Expression, index: Int)
   FieldAccess(container: Expression, label: String)
-  Call(function_name: String, arguments: List(Expression))
-  RecordUpdate(
-    module: option.Option(String),
-    constructior: String,
-    record: Expression,
-    fields: List(#(String, Expression)),
-  )
+  Call(function: Expression, arguments: List(Expression))
+  RecordUpdate(record: Expression, fields: List(Field(Expression)))
   BinaryOperator(name: BinaryOperator, left: Expression, right: Expression)
 }
 

src/transformer.gleam

@@ -105,15 +105,12 @@ fn transform_expression(expression: glance.Expression) -> python.Expression {
     glance.NegateBool(expression) ->
       python.Not(transform_expression(expression))
 
-    glance.Call(glance.Variable(function_name), arguments) -> {
+    glance.Call(function, arguments) -> {
       python.Call(
-        function_name,
+        function: transform_expression(function),
         arguments: list.map(arguments, transform_call_argument),
       )
     }
-    glance.Call(..) -> {
-      panic as "I don't understand how to handle non-valiable calls"
-    }
 
     glance.Tuple(expressions) ->
       expressions
@@ -128,7 +125,7 @@ fn transform_expression(expression: glance.Expression) -> python.Expression {
 
     glance.BinaryOperator(glance.Pipe, left, glance.Variable(function)) -> {
       // simple pipe left |> foo
-      python.Call(function, [transform_expression(left)])
+      python.Call(python.Variable(function), [transform_expression(left)])
     }
 
     glance.BinaryOperator(
@@ -148,7 +145,7 @@ fn transform_expression(expression: glance.Expression) -> python.Expression {
           arguments_after,
         ])
         |> list.map(transform_call_argument)
-      python.Call(function, argument_expressions)
+      python.Call(python.Variable(function), argument_expressions)
     }
     glance.BinaryOperator(glance.Pipe, _, right) -> {
       pprint.debug(right)
@@ -157,8 +154,14 @@ fn transform_expression(expression: glance.Expression) -> python.Expression {
     glance.BinaryOperator(name, left, right) ->
       transform_binop(name, left, right)
 
-    glance.RecordUpdate(module, constructor, record, fields) as expr -> {
-      python.RecordUpdate(module, constructor, record, fields)
+    glance.RecordUpdate(record:, fields:, ..) -> {
+      python.RecordUpdate(
+        record: transform_expression(record),
+        fields: fields
+          |> list.map(fn(tuple) {
+            python.LabelledField(tuple.0, transform_expression(tuple.1))
+          }),
+      )
     }
 
     glance.BitString(_) as expr

test/expression_test.gleam

@@ -511,3 +511,32 @@ def main():
     ",
   )
 }
+
+pub fn record_update_test() {
+  "pub type Foo {
+    Bar(a: Int, b: String)
+  }
+
+  pub fn main() {
+    let foo = Bar(1, \"who\")
+    let bar = Bar(..foo, b: \"you\")
+  }"
+  |> macabre.compile
+  |> should.be_ok
+  |> should.equal(
+    "from gleam_builtins import *
+
+class Foo:
+    @dataclasses.dataclass(frozen=True)
+    class Bar:
+        a: int
+        b: str
+
+Bar = Foo.Bar
+
+
+def main():
+    foo = Bar(1, \"who\")
+    bar = dataclasses.replace(foo, b=\"you\")",
+  )
+}