builtin avg

src/squared_away/squared_away_lang.gleam

@@ -48,7 +48,7 @@ pub fn dependency_list(
       list.flatten([deps, acc])
     }
     typed_expr.BooleanLiteral(_, _) -> acc
-    typed_expr.BuiltinSum(_, keys) ->
+    typed_expr.BuiltinSum(_, keys) | typed_expr.BuiltinAvg(_, keys) ->
       list.map(keys, fn(k) {
         case grid.get(input, k) {
           Error(_) -> [k]
@@ -91,6 +91,7 @@ pub fn parse_grid(
         |> list.map(fn(t) {
           case t {
             token.BuiltinSum(option.None) -> token.BuiltinSum(option.Some(key))
+            token.BuiltinAvg(option.None) -> token.BuiltinAvg(option.Some(key))
             _ -> t
           }
         })

src/squared_away/squared_away_lang/interpreter.gleam

@@ -245,5 +245,67 @@ pub fn interpret(
           )
       }
     }
+    typed_expr.BuiltinAvg(type_:, keys:) -> {
+      let values =
+        grid.to_list(env)
+        |> list.filter_map(fn(i) {
+          let #(gk, item) = i
+          case list.contains(keys, gk) {
+            False -> Error(Nil)
+            True ->
+              case item {
+                Error(_) -> Error(Nil)
+                Ok(x) -> {
+                  interpret(env, x) |> result.nil_error
+                }
+              }
+          }
+        })
+        |> list.filter(fn(v) {
+          case v {
+            value.TestFail | value.TestPass -> False
+            _ -> True
+          }
+        })
+
+      case type_ {
+        typ.TFloat -> {
+          let sum =
+            list.map(values, fn(v) {
+              let assert value.FloatingPointNumber(f) = v
+              f
+            })
+            |> float.sum
+
+          Ok(value.FloatingPointNumber(sum /. int.to_float(list.length(values))))
+        }
+
+        typ.TInt -> {
+          let sum =
+            list.map(values, fn(v) {
+              let assert value.Integer(i) = v
+              i
+            })
+            |> int.sum
+
+          Ok(value.Integer(sum / list.length(values)))
+        }
+
+        typ.TUsd ->
+          list.map(values, fn(v) {
+            let assert value.Usd(d) = v
+            d
+          })
+          |> rational.avg
+          |> value.Usd
+          |> Ok
+        _ ->
+          Error(
+            error.RuntimeError(runtime_error.RuntimeError(
+              "internal compiler error sum function interpret",
+            )),
+          )
+      }
+    }
   }
 }

src/squared_away/squared_away_lang/parser.gleam

@@ -37,6 +37,12 @@ fn do_parse(
         Error(_) -> Ok(#(expr.BuiltinSum(key), rest))
       }
     }
+    [token.BuiltinAvg(key), ..rest] -> {
+      case try_parse_binary_ops(rest) {
+        Ok(#(op, rest)) -> Ok(#(op(expr.BuiltInAvg(key)), rest))
+        Error(_) -> Ok(#(expr.BuiltInAvg(key), rest))
+      }
+    }
     [token.Label(str), ..rest] -> {
       case try_parse_binary_ops(rest) {
         Ok(#(op, rest)) -> Ok(#(op(expr.Label(str)), rest))

src/squared_away/squared_away_lang/parser/expr.gleam

@@ -16,6 +16,7 @@ pub type Expr {
   BinaryOp(lhs: Expr, op: BinaryOpKind, rhs: Expr)
   Group(inner: Expr)
   BuiltinSum(key: option.Option(grid.GridKey))
+  BuiltInAvg(key: option.Option(grid.GridKey))
 }
 
 pub type BinaryOpKind {

src/squared_away/squared_away_lang/scanner.gleam

@@ -96,6 +96,8 @@ fn do_scan(
     "mustbe" <> rest -> do_scan(string.trim_left(rest), [token.MustBe, ..acc])
     "sum" <> rest ->
       do_scan(string.trim_left(rest), [token.BuiltinSum(option.None), ..acc])
+    "avg" <> rest ->
+      do_scan(string.trim_left(rest), [token.BuiltinAvg(option.None), ..acc])
 
     // Operators
     "&&" <> rest -> do_scan(string.trim_left(rest), [token.And, ..acc])

src/squared_away/squared_away_lang/scanner/token.gleam

@@ -53,5 +53,6 @@ pub type Token {
   LabelDef(txt: String)
   Underscore
   BuiltinSum(key: option.Option(grid.GridKey))
+  BuiltinAvg(key: option.Option(grid.GridKey))
   MustBe
 }

src/squared_away/squared_away_lang/typechecker.gleam

@@ -91,6 +91,81 @@ pub fn typecheck(
           )
       }
     }
+    expr.BuiltInAvg(key) -> {
+      let assert option.Some(key) = key
+
+      // The sum builtin will sum up all the values above it until it finds a label, so we need to fetch those 
+      // values and sort them
+      let items_above_sum_call =
+        grid.to_list(env)
+        |> list.filter(fn(i) {
+          let #(gk, _) = i
+          grid.col(gk) == grid.col(key) && grid.row(gk) < grid.row(key)
+        })
+        |> list.sort(fn(i1, i2) {
+          let #(gk1, _) = i1
+          let #(gk2, _) = i2
+          int.compare(grid.row(gk1), grid.row(gk2))
+        })
+        |> list.reverse
+        |> list.take_while(fn(i) {
+          let #(_, item) = i
+          case item {
+            Ok(expr.LabelDef(_)) -> False
+            _ -> True
+          }
+        })
+
+      let keys = list.map(items_above_sum_call, fn(i) { i.0 })
+      let items_above_sum_call = list.map(items_above_sum_call, fn(i) { i.1 })
+
+      use <- bool.guard(
+        list.any(items_above_sum_call, result.is_error),
+        Error(
+          error.TypeError(type_error.TypeError(
+            "Cell above sum expression has error",
+          )),
+        ),
+      )
+
+      let types =
+        list.map(items_above_sum_call, fn(i) {
+          let assert Ok(item) = i
+          item
+        })
+        |> list.unique
+        |> list.map(fn(e) { typecheck(env, e) })
+
+      use <- bool.guard(
+        list.any(types, result.is_error),
+        Error(
+          error.TypeError(type_error.TypeError(
+            "Cell above sum expression has type error",
+          )),
+        ),
+      )
+
+      let types =
+        list.map(types, fn(t) {
+          let assert Ok(texpr) = t
+          texpr.type_
+        })
+        |> list.unique
+        |> list.filter(fn(t) { t != typ.TTestResult })
+
+      case types {
+        [typ.TFloat] -> Ok(typed_expr.BuiltinAvg(typ.TFloat, keys))
+        [typ.TInt] -> Ok(typed_expr.BuiltinAvg(typ.TInt, keys))
+        [typ.TUsd] -> Ok(typed_expr.BuiltinAvg(typ.TUsd, keys))
+        [typ.TPercent] -> Ok(typed_expr.BuiltinAvg(typ.TPercent, keys))
+        _ ->
+          Error(
+            error.TypeError(type_error.TypeError(
+              "avg function can only be used on floats, integers, and USD.",
+            )),
+          )
+      }
+    }
     expr.LabelDef(txt) -> {
       // Duplicate label definitions should be a type error
       let defs =

src/squared_away/squared_away_lang/typechecker/typed_expr.gleam

@@ -30,6 +30,7 @@ pub type TypedExpr {
   )
   Group(type_: typ.Typ, expr: TypedExpr)
   BuiltinSum(type_: typ.Typ, keys: List(grid.GridKey))
+  BuiltinAvg(type_: typ.Typ, keys: List(grid.GridKey))
 }
 
 pub fn visit_cross_labels(
@@ -97,6 +98,7 @@ fn do_to_string(te: TypedExpr) -> String {
       <> " "
       <> do_to_string(rhs)
     BuiltinSum(_, _) -> "sum"
+    BuiltinAvg(_, _) -> "avg"
     UsdLiteral(_, dollars) -> {
       let str = "$" <> rational.to_string(dollars, 100, False)
       case string.split_once(str, ".") {

src/squared_away/squared_away_lang/util/rational.gleam

@@ -78,6 +78,10 @@ pub fn sum(rats: List(Rat)) -> Rat {
   list.fold(rats, from_int(0), add)
 }
 
+pub fn avg(rats: List(Rat)) -> Rat {
+  sum(rats) |> divide(list.length(rats) |> from_int)
+}
+
 pub fn to_string(rat: Rat, precision: Int, with_commas: Bool) -> String {
   let Rat(n, d) = rat
   let whole = bigi.to_string(bigi.divide(n, d))