kumi 0.0.17 → 0.0.19

data/golden/shift_2d/expected/snast.txt

@@ -0,0 +1,74 @@
+(SNAST
+  (VALUE shift_cols_right_zero
+    (Call :shift
+      (InputRef rows.col.v key_chain=[]) :: [rows, col] -> integer
+      (Const 1) :: [] -> integer
+    ) :: [rows, col] -> integer
+  ) :: [rows, col] -> integer
+  (VALUE shift_cols_right_clamp
+    (Call :shift
+      (InputRef rows.col.v key_chain=[]) :: [rows, col] -> integer
+      (Const 1) :: [] -> integer
+    ) :: [rows, col] -> integer
+  ) :: [rows, col] -> integer
+  (VALUE shift_cols_right_wrap
+    (Call :shift
+      (InputRef rows.col.v key_chain=[]) :: [rows, col] -> integer
+      (Const 1) :: [] -> integer
+    ) :: [rows, col] -> integer
+  ) :: [rows, col] -> integer
+  (VALUE shift_cols_left_zero
+    (Call :shift
+      (InputRef rows.col.v key_chain=[]) :: [rows, col] -> integer
+      (Const -1) :: [] -> integer
+    ) :: [rows, col] -> integer
+  ) :: [rows, col] -> integer
+  (VALUE shift_cols_left_clamp
+    (Call :shift
+      (InputRef rows.col.v key_chain=[]) :: [rows, col] -> integer
+      (Const -1) :: [] -> integer
+    ) :: [rows, col] -> integer
+  ) :: [rows, col] -> integer
+  (VALUE shift_cols_left_wrap
+    (Call :shift
+      (InputRef rows.col.v key_chain=[]) :: [rows, col] -> integer
+      (Const -1) :: [] -> integer
+    ) :: [rows, col] -> integer
+  ) :: [rows, col] -> integer
+  (VALUE shift_rows_down_zero
+    (Call :shift
+      (InputRef rows.col.v key_chain=[]) :: [rows, col] -> integer
+      (Const 1) :: [] -> integer
+    ) :: [rows, col] -> integer
+  ) :: [rows, col] -> integer
+  (VALUE shift_rows_down_clamp
+    (Call :shift
+      (InputRef rows.col.v key_chain=[]) :: [rows, col] -> integer
+      (Const 1) :: [] -> integer
+    ) :: [rows, col] -> integer
+  ) :: [rows, col] -> integer
+  (VALUE shift_rows_down_wrap
+    (Call :shift
+      (InputRef rows.col.v key_chain=[]) :: [rows, col] -> integer
+      (Const 1) :: [] -> integer
+    ) :: [rows, col] -> integer
+  ) :: [rows, col] -> integer
+  (VALUE shift_rows_up_zero
+    (Call :shift
+      (InputRef rows.col.v key_chain=[]) :: [rows, col] -> integer
+      (Const -1) :: [] -> integer
+    ) :: [rows, col] -> integer
+  ) :: [rows, col] -> integer
+  (VALUE shift_rows_up_clamp
+    (Call :shift
+      (InputRef rows.col.v key_chain=[]) :: [rows, col] -> integer
+      (Const -1) :: [] -> integer
+    ) :: [rows, col] -> integer
+  ) :: [rows, col] -> integer
+  (VALUE shift_rows_up_wrap
+    (Call :shift
+      (InputRef rows.col.v key_chain=[]) :: [rows, col] -> integer
+      (Const -1) :: [] -> integer
+    ) :: [rows, col] -> integer
+  ) :: [rows, col] -> integer
+)

data/golden/shift_2d/expected.json

@@ -0,0 +1,15 @@
+{
+  "shift_cols_right_zero":  [[0, 1, 2],   [0, 10, 20]],
+  "shift_cols_right_clamp": [[1, 1, 2],   [10, 10, 20]],
+  "shift_cols_right_wrap":  [[3, 1, 2],   [30, 10, 20]],
+  "shift_cols_left_zero":   [[2, 3, 0],   [20, 30, 0]],
+  "shift_cols_left_clamp":  [[2, 3, 3],   [20, 30, 30]],
+  "shift_cols_left_wrap":   [[2, 3, 1],   [20, 30, 10]],
+
+  "shift_rows_down_zero":   [[0, 0, 0],   [1, 2, 3]],
+  "shift_rows_down_clamp":  [[1, 2, 3],   [1, 2, 3]],
+  "shift_rows_down_wrap":   [[10, 20, 30],[1, 2, 3]],
+  "shift_rows_up_zero":     [[10, 20, 30],[0, 0, 0]],
+  "shift_rows_up_clamp":    [[10, 20, 30],[10, 20, 30]],
+  "shift_rows_up_wrap":     [[10, 20, 30],[1, 2, 3]]
+}

data/golden/shift_2d/input.json

@@ -0,0 +1,14 @@
+{
+  "rows": [
+    [
+      1,
+      2,
+      3
+    ],
+    [
+      10,
+      20,
+      30
+    ]
+  ]
+}

data/golden/shift_2d/schema.kumi

@@ -0,0 +1,25 @@
+schema do
+  input do
+    array :rows do
+      array :col do
+        integer :v
+      end
+    end
+  end
+
+  # Column-wise (axis_offset = 0)
+  value :shift_cols_right_zero,  shift(input.rows.col.v,  1)
+  value :shift_cols_right_clamp, shift(input.rows.col.v,  1, policy: :clamp)
+  value :shift_cols_right_wrap,  shift(input.rows.col.v,  1, policy: :wrap)
+  value :shift_cols_left_zero,   shift(input.rows.col.v, -1)
+  value :shift_cols_left_clamp,  shift(input.rows.col.v, -1, policy: :clamp)
+  value :shift_cols_left_wrap,   shift(input.rows.col.v, -1, policy: :wrap)
+
+  # Row-wise (axis_offset = 1)
+  value :shift_rows_down_zero,   shift(input.rows.col.v,  1, axis_offset: 1)
+  value :shift_rows_down_clamp,  shift(input.rows.col.v,  1, axis_offset: 1, policy: :clamp)
+  value :shift_rows_down_wrap,   shift(input.rows.col.v,  1, axis_offset: 1, policy: :wrap)
+  value :shift_rows_up_zero,     shift(input.rows.col.v, -1, axis_offset: 1)
+  value :shift_rows_up_clamp,    shift(input.rows.col.v, -1, axis_offset: 1, policy: :clamp)
+  value :shift_rows_up_wrap,     shift(input.rows.col.v, -1, axis_offset: 1, policy: :wrap)
+end

data/golden/simple_math/expected/ast.txt

@@ -0,0 +1,40 @@
+(Root
+  inputs: [
+    (InputDeclaration :x :integer)
+    (InputDeclaration :y :integer)
+  ]
+  values: [
+    (ValueDeclaration :sum
+      (CallExpression :add
+        (InputReference :x)
+        (InputReference :y)
+      )
+    )
+    (ValueDeclaration :product
+      (CallExpression :multiply
+        (InputReference :x)
+        (InputReference :y)
+      )
+    )
+    (ValueDeclaration :difference
+      (CallExpression :subtract
+        (InputReference :x)
+        (InputReference :y)
+      )
+    )
+    (ValueDeclaration :results_array
+      (ArrayExpression
+        (Literal 1)
+        (CallExpression :add
+          (InputReference :x)
+          (Literal 10)
+        )
+        (CallExpression :multiply
+          (InputReference :y)
+          (Literal 2)
+        )
+      )
+    )
+  ]
+  traits: []
+)

data/golden/simple_math/expected/input_plan.txt

@@ -0,0 +1,2 @@
+x: integer
+y: integer

data/golden/simple_math/expected/lir_00_unoptimized.txt

@@ -0,0 +1,31 @@
+(LIR
+  (Declaration sum
+    %t1 = load_input "x" :: integer
+    %t2 = load_input "y" :: integer
+    %t3 = call core.add(%t1, %t2) :: integer
+    yield %t3
+  )
+  (Declaration product
+    %t4 = load_input "x" :: integer
+    %t5 = load_input "y" :: integer
+    %t6 = call core.mul(%t4, %t5) :: integer
+    yield %t6
+  )
+  (Declaration difference
+    %t7 = load_input "x" :: integer
+    %t8 = load_input "y" :: integer
+    %t9 = call core.sub(%t7, %t8) :: integer
+    yield %t9
+  )
+  (Declaration results_array
+    %t10 = const 1 :: integer
+    %t11 = load_input "x" :: integer
+    %t12 = const 10 :: integer
+    %t13 = call core.add(%t11, %t12) :: integer
+    %t14 = load_input "y" :: integer
+    %t15 = const 2 :: integer
+    %t16 = call core.mul(%t14, %t15) :: integer
+    %t17 = make_tuple(%t10, %t13, %t16) :: tuple<integer>
+    yield %t17
+  )
+)

data/golden/simple_math/expected/lir_01_hoist_scalar_references.txt

@@ -0,0 +1,31 @@
+(LIR
+  (Declaration sum
+    %t1 = load_input "x" :: integer
+    %t2 = load_input "y" :: integer
+    %t3 = call core.add(%t1, %t2) :: integer
+    yield %t3
+  )
+  (Declaration product
+    %t4 = load_input "x" :: integer
+    %t5 = load_input "y" :: integer
+    %t6 = call core.mul(%t4, %t5) :: integer
+    yield %t6
+  )
+  (Declaration difference
+    %t7 = load_input "x" :: integer
+    %t8 = load_input "y" :: integer
+    %t9 = call core.sub(%t7, %t8) :: integer
+    yield %t9
+  )
+  (Declaration results_array
+    %t10 = const 1 :: integer
+    %t11 = load_input "x" :: integer
+    %t12 = const 10 :: integer
+    %t13 = call core.add(%t11, %t12) :: integer
+    %t14 = load_input "y" :: integer
+    %t15 = const 2 :: integer
+    %t16 = call core.mul(%t14, %t15) :: integer
+    %t17 = make_tuple(%t10, %t13, %t16) :: tuple<integer>
+    yield %t17
+  )
+)

data/golden/simple_math/expected/lir_02_inlined.txt

@@ -0,0 +1,31 @@
+(LIR
+  (Declaration sum
+    %t1 = load_input "x" :: integer
+    %t2 = load_input "y" :: integer
+    %t3 = call core.add(%t1, %t2) :: integer
+    yield %t3
+  )
+  (Declaration product
+    %t4 = load_input "x" :: integer
+    %t5 = load_input "y" :: integer
+    %t6 = call core.mul(%t4, %t5) :: integer
+    yield %t6
+  )
+  (Declaration difference
+    %t7 = load_input "x" :: integer
+    %t8 = load_input "y" :: integer
+    %t9 = call core.sub(%t7, %t8) :: integer
+    yield %t9
+  )
+  (Declaration results_array
+    %t10 = const 1 :: integer
+    %t11 = load_input "x" :: integer
+    %t12 = const 10 :: integer
+    %t13 = call core.add(%t11, %t12) :: integer
+    %t14 = load_input "y" :: integer
+    %t15 = const 2 :: integer
+    %t16 = call core.mul(%t14, %t15) :: integer
+    %t17 = make_tuple(%t10, %t13, %t16) :: tuple<integer>
+    yield %t17
+  )
+)

data/golden/simple_math/expected/lir_03_cse.txt

@@ -0,0 +1,31 @@
+(LIR
+  (Declaration sum
+    %t1 = load_input "x" :: integer
+    %t2 = load_input "y" :: integer
+    %t3 = call core.add(%t1, %t2) :: integer
+    yield %t3
+  )
+  (Declaration product
+    %t4 = load_input "x" :: integer
+    %t5 = load_input "y" :: integer
+    %t6 = call core.mul(%t4, %t5) :: integer
+    yield %t6
+  )
+  (Declaration difference
+    %t7 = load_input "x" :: integer
+    %t8 = load_input "y" :: integer
+    %t9 = call core.sub(%t7, %t8) :: integer
+    yield %t9
+  )
+  (Declaration results_array
+    %t10 = const 1 :: integer
+    %t11 = load_input "x" :: integer
+    %t12 = const 10 :: integer
+    %t13 = call core.add(%t11, %t12) :: integer
+    %t14 = load_input "y" :: integer
+    %t15 = const 2 :: integer
+    %t16 = call core.mul(%t14, %t15) :: integer
+    %t17 = make_tuple(%t10, %t13, %t16) :: tuple<integer>
+    yield %t17
+  )
+)

data/golden/simple_math/expected/lir_04_1_loop_fusion.txt

@@ -0,0 +1,31 @@
+(LIR
+  (Declaration sum
+    %t1 = load_input "x" :: integer
+    %t2 = load_input "y" :: integer
+    %t3 = call core.add(%t1, %t2) :: integer
+    yield %t3
+  )
+  (Declaration product
+    %t4 = load_input "x" :: integer
+    %t5 = load_input "y" :: integer
+    %t6 = call core.mul(%t4, %t5) :: integer
+    yield %t6
+  )
+  (Declaration difference
+    %t7 = load_input "x" :: integer
+    %t8 = load_input "y" :: integer
+    %t9 = call core.sub(%t7, %t8) :: integer
+    yield %t9
+  )
+  (Declaration results_array
+    %t10 = const 1 :: integer
+    %t11 = load_input "x" :: integer
+    %t12 = const 10 :: integer
+    %t13 = call core.add(%t11, %t12) :: integer
+    %t14 = load_input "y" :: integer
+    %t15 = const 2 :: integer
+    %t16 = call core.mul(%t14, %t15) :: integer
+    %t17 = make_tuple(%t10, %t13, %t16) :: tuple<integer>
+    yield %t17
+  )
+)

data/golden/simple_math/expected/lir_04_loop_invcm.txt

@@ -0,0 +1,31 @@
+(LIR
+  (Declaration sum
+    %t1 = load_input "x" :: integer
+    %t2 = load_input "y" :: integer
+    %t3 = call core.add(%t1, %t2) :: integer
+    yield %t3
+  )
+  (Declaration product
+    %t4 = load_input "x" :: integer
+    %t5 = load_input "y" :: integer
+    %t6 = call core.mul(%t4, %t5) :: integer
+    yield %t6
+  )
+  (Declaration difference
+    %t7 = load_input "x" :: integer
+    %t8 = load_input "y" :: integer
+    %t9 = call core.sub(%t7, %t8) :: integer
+    yield %t9
+  )
+  (Declaration results_array
+    %t10 = const 1 :: integer
+    %t11 = load_input "x" :: integer
+    %t12 = const 10 :: integer
+    %t13 = call core.add(%t11, %t12) :: integer
+    %t14 = load_input "y" :: integer
+    %t15 = const 2 :: integer
+    %t16 = call core.mul(%t14, %t15) :: integer
+    %t17 = make_tuple(%t10, %t13, %t16) :: tuple<integer>
+    yield %t17
+  )
+)

data/golden/simple_math/expected/lir_06_const_prop.txt

@@ -0,0 +1,31 @@
+(LIR
+  (Declaration sum
+    %t1 = load_input "x" :: integer
+    %t2 = load_input "y" :: integer
+    %t3 = call core.add(%t1, %t2) :: integer
+    yield %t3
+  )
+  (Declaration product
+    %t4 = load_input "x" :: integer
+    %t5 = load_input "y" :: integer
+    %t6 = call core.mul(%t4, %t5) :: integer
+    yield %t6
+  )
+  (Declaration difference
+    %t7 = load_input "x" :: integer
+    %t8 = load_input "y" :: integer
+    %t9 = call core.sub(%t7, %t8) :: integer
+    yield %t9
+  )
+  (Declaration results_array
+    %t10 = const 1 :: integer
+    %t11 = load_input "x" :: integer
+    %t12 = const 10 :: integer
+    %t13 = call core.add(%t11, %t12) :: integer
+    %t14 = load_input "y" :: integer
+    %t15 = const 2 :: integer
+    %t16 = call core.mul(%t14, %t15) :: integer
+    %t17 = make_tuple(%t10, %t13, %t16) :: tuple<integer>
+    yield %t17
+  )
+)

data/golden/simple_math/expected/nast.txt

@@ -0,0 +1,33 @@
+(NAST
+  (VALUE sum
+    (Call :"core.add"
+    (InputRef [:x])
+    (InputRef [:y])
+  )
+  )
+  (VALUE product
+    (Call :"core.mul"
+    (InputRef [:x])
+    (InputRef [:y])
+  )
+  )
+  (VALUE difference
+    (Call :"core.sub"
+    (InputRef [:x])
+    (InputRef [:y])
+  )
+  )
+  (VALUE results_array
+    (Tuple
+    (Const 1)
+    (Call :"core.add"
+      (InputRef [:x])
+      (Const 10)
+    )
+    (Call :"core.mul"
+      (InputRef [:y])
+      (Const 2)
+    )
+  )
+  )
+)

data/golden/simple_math/expected/schema_javascript.mjs

@@ -0,0 +1,33 @@
+export function _sum(input) {
+  let t1 = input["x"];
+  let t2 = input["y"];
+  let t3 = t1 + t2;
+  return t3;
+}
+
+export function _product(input) {
+  let t4 = input["x"];
+  let t5 = input["y"];
+  let t6 = t4 * t5;
+  return t6;
+}
+
+export function _difference(input) {
+  let t7 = input["x"];
+  let t8 = input["y"];
+  let t9 = t7 - t8;
+  return t9;
+}
+
+export function _results_array(input) {
+  const t10 = 1;
+  let t11 = input["x"];
+  const t12 = 10;
+  let t13 = t11 + t12;
+  let t14 = input["y"];
+  const t15 = 2;
+  let t16 = t14 * t15;
+  let t17 = [t10, t13, t16];
+  return t17;
+}
+

data/golden/simple_math/expected/schema_ruby.rb

@@ -0,0 +1,59 @@
+# Autogenerated by Kumi Codegen
+module Kumi::Compiled::KUMI_669f10737cc7b153a1649261f566d16d64db11a493067c2685f5ebc85ab176e8
+  def self.from(input_data = nil)
+    instance = Object.new
+    instance.extend(self)
+    instance.instance_variable_set(:@input, input_data)
+    instance
+  end
+
+  def self.__kumi_executable__
+    instance = Object.new
+    instance.extend(self)
+    instance
+  end
+
+  def update(input_data)
+    @input = @input.merge(input_data)
+    self
+  end
+
+  def [](name)
+    case name
+    when :sum then _sum
+    when :product then _product
+    when :difference then _difference
+    when :results_array then _results_array
+    else raise KeyError, "Unknown declaration"
+    end
+  end
+
+  def _sum(input = @input)
+    t1 = input["x"] || input[:x]
+    t2 = input["y"] || input[:y]
+    t1 + t2
+  end
+
+  def _product(input = @input)
+    t4 = input["x"] || input[:x]
+    t5 = input["y"] || input[:y]
+    t4 * t5
+  end
+
+  def _difference(input = @input)
+    t7 = input["x"] || input[:x]
+    t8 = input["y"] || input[:y]
+    t7 - t8
+  end
+
+  def _results_array(input = @input)
+    t10 = 1
+    t11 = input["x"] || input[:x]
+    t12 = 10
+    t13 = t11 + t12
+    t14 = input["y"] || input[:y]
+    t15 = 2
+    t16 = t14 * t15
+    [t10, t13, t16]
+  end
+end

data/golden/simple_math/expected/snast.txt

@@ -0,0 +1,33 @@
+(SNAST
+  (VALUE sum
+    (Call :core.add
+      (InputRef x key_chain=[]) :: [] -> integer
+      (InputRef y key_chain=[]) :: [] -> integer
+    ) :: [] -> integer
+  ) :: [] -> integer
+  (VALUE product
+    (Call :core.mul
+      (InputRef x key_chain=[]) :: [] -> integer
+      (InputRef y key_chain=[]) :: [] -> integer
+    ) :: [] -> integer
+  ) :: [] -> integer
+  (VALUE difference
+    (Call :core.sub
+      (InputRef x key_chain=[]) :: [] -> integer
+      (InputRef y key_chain=[]) :: [] -> integer
+    ) :: [] -> integer
+  ) :: [] -> integer
+  (VALUE results_array
+    (Tuple
+      (Const 1) :: [] -> integer
+      (Call :core.add
+        (InputRef x key_chain=[]) :: [] -> integer
+        (Const 10) :: [] -> integer
+      ) :: [] -> integer
+      (Call :core.mul
+        (InputRef y key_chain=[]) :: [] -> integer
+        (Const 2) :: [] -> integer
+      ) :: [] -> integer
+    ) :: [] -> tuple<integer>
+  ) :: [] -> tuple<integer>
+)

data/golden/simple_math/expected.json

@@ -0,0 +1 @@
+{"sum": 8, "product": 15, "difference": 2, "results_array": [1, 15, 6]}

data/golden/simple_math/input.json

@@ -0,0 +1,4 @@
+{
+  "x": 5,
+  "y": 3
+}

data/golden/simple_math/schema.kumi

@@ -4,7 +4,8 @@ schema do
     integer :y
   end
 
-  value :sum, input.x**input.y
+  value :sum, input.x + input.y
   value :product, input.x * input.y
   value :difference, input.x - input.y
+  value :results_array, [1, input.x + 10, input.y * 2]
 end

data/golden/streaming_basics/expected/ast.txt

@@ -0,0 +1,64 @@
+(Root
+  inputs: [
+    (InputDeclaration :items :array
+      [
+        (InputDeclaration :item :hash
+          [
+            (InputDeclaration :price :float)
+            (InputDeclaration :qty :integer)
+          ]
+        )
+      ]
+    )
+    (InputDeclaration :discount :float)
+  ]
+  values: [
+    (ValueDeclaration :items_subtotal
+      (CallExpression :multiply
+        (InputElementReference items.item.price)
+        (InputElementReference items.item.qty)
+      )
+    )
+    (ValueDeclaration :items_discounted
+      (CallExpression :multiply
+        (InputElementReference items.item.price)
+        (CallExpression :subtract
+          (Literal 1.0)
+          (InputReference :discount)
+        )
+      )
+    )
+    (ValueDeclaration :items_is_big
+      (CallExpression :>
+        (InputElementReference items.item.price)
+        (Literal 100.0)
+      )
+    )
+    (ValueDeclaration :items_effective
+      (CallExpression :select
+        (DeclarationReference :items_is_big)
+        (CallExpression :multiply
+          (DeclarationReference :items_subtotal)
+          (Literal 0.9)
+        )
+        (DeclarationReference :items_subtotal)
+      )
+    )
+    (ValueDeclaration :total_qty
+      (CallExpression :sum
+        (InputElementReference items.item.qty)
+      )
+    )
+    (ValueDeclaration :cart_total
+      (CallExpression :sum
+        (DeclarationReference :items_subtotal)
+      )
+    )
+    (ValueDeclaration :cart_total_effective
+      (CallExpression :sum
+        (DeclarationReference :items_effective)
+      )
+    )
+  ]
+  traits: []
+)

data/golden/streaming_basics/expected/input_plan.txt

@@ -0,0 +1,8 @@
+items: array (array) access_mode=element
+  └─> item: element_access
+  item: hash (hash)
+    └─> price: property_access
+    └─> qty: property_access
+    price: float
+    qty: integer
+discount: float