kumi 0.0.18 → 0.0.20

data/golden/array_operations/expected/schema_ruby.rb

@@ -0,0 +1,91 @@
+# Autogenerated by Kumi Codegen
+module Kumi::Compiled::KUMI_d1c9f17db78e51ee1d92553426415c98ea436e202c29221735f0456eb9d070ac
+  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 :subtotals then _subtotals
+    when :discounted_price then _discounted_price
+    when :is_valid_quantity then _is_valid_quantity
+    when :expensive_items then _expensive_items
+    when :electronics then _electronics
+    else raise KeyError, "Unknown declaration"
+    end
+  end
+
+  def _subtotals(input = @input)
+    out = []
+    t1 = input["items"] || input[:items]
+    t1.each_with_index do |items_el_2, items_i_3|
+      t4 = items_el_2["price"] || items_el_2[:price]
+      t5 = items_el_2["quantity"] || items_el_2[:quantity]
+      t6 = t4 * t5
+      out << t6
+    end
+    out
+  end
+
+  def _discounted_price(input = @input)
+    out = []
+    t7 = input["items"] || input[:items]
+    t11 = 0.9
+    t7.each_with_index do |items_el_8, items_i_9|
+      t10 = items_el_8["price"] || items_el_8[:price]
+      t12 = t10 * t11
+      out << t12
+    end
+    out
+  end
+
+  def _is_valid_quantity(input = @input)
+    out = []
+    t13 = input["items"] || input[:items]
+    t17 = 0
+    t13.each_with_index do |items_el_14, items_i_15|
+      t16 = items_el_14["quantity"] || items_el_14[:quantity]
+      t18 = t16 > t17
+      out << t18
+    end
+    out
+  end
+
+  def _expensive_items(input = @input)
+    out = []
+    t19 = input["items"] || input[:items]
+    t23 = 100.0
+    t19.each_with_index do |items_el_20, items_i_21|
+      t22 = items_el_20["price"] || items_el_20[:price]
+      t24 = t22 > t23
+      out << t24
+    end
+    out
+  end
+
+  def _electronics(input = @input)
+    out = []
+    t25 = input["items"] || input[:items]
+    t29 = "electronics"
+    t25.each_with_index do |items_el_26, items_i_27|
+      t28 = items_el_26["category"] || items_el_26[:category]
+      t30 = t28 == t29
+      out << t30
+    end
+    out
+  end
+end

data/golden/array_operations/expected/snast.txt

@@ -0,0 +1,32 @@
+(SNAST
+  (VALUE subtotals
+    (Call :core.mul
+      (InputRef items.item.price key_chain=[]) :: [items] -> float
+      (InputRef items.item.quantity key_chain=[]) :: [items] -> integer
+    ) :: [items] -> float
+  ) :: [items] -> float
+  (VALUE discounted_price
+    (Call :core.mul
+      (InputRef items.item.price key_chain=[]) :: [items] -> float
+      (Const 0.9) :: [] -> float
+    ) :: [items] -> float
+  ) :: [items] -> float
+  (TRAIT is_valid_quantity
+    (Call :core.gt
+      (InputRef items.item.quantity key_chain=[]) :: [items] -> integer
+      (Const 0) :: [] -> integer
+    ) :: [items] -> boolean
+  ) :: [items] -> boolean
+  (TRAIT expensive_items
+    (Call :core.gt
+      (InputRef items.item.price key_chain=[]) :: [items] -> float
+      (Const 100.0) :: [] -> float
+    ) :: [items] -> boolean
+  ) :: [items] -> boolean
+  (TRAIT electronics
+    (Call :core.eq
+      (InputRef items.item.category key_chain=[]) :: [items] -> string
+      (Const "electronics") :: [] -> string
+    ) :: [items] -> boolean
+  ) :: [items] -> boolean
+)

data/golden/array_operations/expected.json

@@ -0,0 +1,27 @@
+{
+  "subtotals": [
+    300.0,
+    75.0,
+    600.0
+  ],
+  "expensive_items": [
+    true,
+    false,
+    true
+  ],
+  "electronics": [
+    true,
+    false,
+    true
+  ],
+  "discounted_price": [
+    135.0,
+    67.5,
+    180.0
+  ],
+  "is_valid_quantity": [
+    true,
+    true,
+    true
+  ]
+}

data/golden/array_operations/input.json

@@ -0,0 +1,8 @@
+{
+  "items": [
+    {"price": 150.0, "quantity": 2, "category": "electronics"},
+    {"price": 75.0, "quantity": 1, "category": "books"}, 
+    {"price": 200.0, "quantity": 3, "category": "electronics"}
+  ],
+  "tax_rate": 0.08
+}

data/golden/array_operations/schema.kumi

@@ -1,17 +1,19 @@
 schema do
   input do
     array :items do
-      float :price
-      integer :quantity
-      string :category
+      hash :item do
+        float :price
+        integer :quantity
+        string :category
+      end
     end
     float :tax_rate
   end
-  
-  value :subtotals, input.items.price * input.items.quantity
-  trait :expensive_items, input.items.price > 100.0
-  trait :electronics, input.items.category == "electronics"
-  
-  value :discounted_price, input.items.price * 0.9
-  value :is_valid_quantity, input.items.quantity > 0
+
+  value :subtotals, input.items.item.price * input.items.item.quantity
+  trait :expensive_items, input.items.item.price > 100.0
+  trait :electronics, input.items.item.category == "electronics"
+
+  value :discounted_price, input.items.item.price * 0.9
+  value :is_valid_quantity, input.items.item.quantity > 0
 end

data/golden/cascade_logic/expected/ast.txt

@@ -0,0 +1,37 @@
+(Root
+  inputs: [
+    (InputDeclaration :x :integer)
+    (InputDeclaration :y :integer)
+  ]
+  values: [
+    (ValueDeclaration :status
+      (CascadeExpression
+        ((CallExpression :cascade_and
+        (DeclarationReference :y_positive)
+        (DeclarationReference :x_positive)
+      ) (Literal "both positive"))
+        ((CallExpression :cascade_and
+        (DeclarationReference :x_positive)
+      ) (Literal "x positive"))
+        ((CallExpression :cascade_and
+        (DeclarationReference :y_positive)
+      ) (Literal "y positive"))
+        ((Literal true) (Literal "neither positive"))
+      )
+    )
+  ]
+  traits: [
+    (TraitDeclaration :x_positive
+      (CallExpression :>
+        (InputReference :x)
+        (Literal 0)
+      )
+    )
+    (TraitDeclaration :y_positive
+      (CallExpression :>
+        (InputReference :y)
+        (Literal 0)
+      )
+    )
+  ]
+)

data/golden/cascade_logic/expected/input_plan.txt

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

data/golden/cascade_logic/expected/lir_00_unoptimized.txt

@@ -0,0 +1,29 @@
+(LIR
+  (Declaration y_positive
+    %t1 = load_input "y" :: integer
+    %t2 = const 0 :: integer
+    %t3 = call core.gt(%t1, %t2) :: boolean
+    yield %t3
+  )
+  (Declaration x_positive
+    %t4 = load_input "x" :: integer
+    %t5 = const 0 :: integer
+    %t6 = call core.gt(%t4, %t5) :: boolean
+    yield %t6
+  )
+  (Declaration status
+    %t7 = load_decl y_positive :: boolean
+    %t8 = load_decl x_positive :: boolean
+    %t9 = call core.and(%t7, %t8) :: boolean
+    %t10 = const "both positive" :: string
+    %t11 = load_decl x_positive :: boolean
+    %t12 = const "x positive" :: string
+    %t13 = load_decl y_positive :: boolean
+    %t14 = const "y positive" :: string
+    %t15 = const "neither positive" :: string
+    %t16 = select %t13, %t14, %t15 :: string
+    %t17 = select %t11, %t12, %t16 :: string
+    %t18 = select %t9, %t10, %t17 :: string
+    yield %t18
+  )
+)

data/golden/cascade_logic/expected/lir_01_hoist_scalar_references.txt

@@ -0,0 +1,29 @@
+(LIR
+  (Declaration y_positive
+    %t1 = load_input "y" :: integer
+    %t2 = const 0 :: integer
+    %t3 = call core.gt(%t1, %t2) :: boolean
+    yield %t3
+  )
+  (Declaration x_positive
+    %t4 = load_input "x" :: integer
+    %t5 = const 0 :: integer
+    %t6 = call core.gt(%t4, %t5) :: boolean
+    yield %t6
+  )
+  (Declaration status
+    %t7 = load_decl y_positive :: boolean
+    %t8 = load_decl x_positive :: boolean
+    %t9 = call core.and(%t7, %t8) :: boolean
+    %t10 = const "both positive" :: string
+    %t11 = load_decl x_positive :: boolean
+    %t12 = const "x positive" :: string
+    %t13 = load_decl y_positive :: boolean
+    %t14 = const "y positive" :: string
+    %t15 = const "neither positive" :: string
+    %t16 = select %t13, %t14, %t15 :: string
+    %t17 = select %t11, %t12, %t16 :: string
+    %t18 = select %t9, %t10, %t17 :: string
+    yield %t18
+  )
+)

data/golden/cascade_logic/expected/lir_02_inlined.txt

@@ -0,0 +1,37 @@
+(LIR
+  (Declaration y_positive
+    %t1 = load_input "y" :: integer
+    %t2 = const 0 :: integer
+    %t3 = call core.gt(%t1, %t2) :: boolean
+    yield %t3
+  )
+  (Declaration x_positive
+    %t4 = load_input "x" :: integer
+    %t5 = const 0 :: integer
+    %t6 = call core.gt(%t4, %t5) :: boolean
+    yield %t6
+  )
+  (Declaration status
+    %t19 = load_input "y" :: integer
+    %t20 = const 0 :: integer
+    %t21 = call core.gt(%t19, %t20) :: boolean
+    %t22 = load_input "x" :: integer
+    %t23 = const 0 :: integer
+    %t24 = call core.gt(%t22, %t23) :: boolean
+    %t9 = call core.and(%t21, %t24) :: boolean
+    %t10 = const "both positive" :: string
+    %t22 = load_input "x" :: integer
+    %t23 = const 0 :: integer
+    %t24 = call core.gt(%t22, %t23) :: boolean
+    %t12 = const "x positive" :: string
+    %t19 = load_input "y" :: integer
+    %t20 = const 0 :: integer
+    %t21 = call core.gt(%t19, %t20) :: boolean
+    %t14 = const "y positive" :: string
+    %t15 = const "neither positive" :: string
+    %t16 = select %t21, %t14, %t15 :: string
+    %t17 = select %t24, %t12, %t16 :: string
+    %t18 = select %t9, %t10, %t17 :: string
+    yield %t18
+  )
+)

data/golden/cascade_logic/expected/lir_03_cse.txt

@@ -0,0 +1,30 @@
+(LIR
+  (Declaration y_positive
+    %t1 = load_input "y" :: integer
+    %t2 = const 0 :: integer
+    %t3 = call core.gt(%t1, %t2) :: boolean
+    yield %t3
+  )
+  (Declaration x_positive
+    %t4 = load_input "x" :: integer
+    %t5 = const 0 :: integer
+    %t6 = call core.gt(%t4, %t5) :: boolean
+    yield %t6
+  )
+  (Declaration status
+    %t19 = load_input "y" :: integer
+    %t20 = const 0 :: integer
+    %t21 = call core.gt(%t19, %t20) :: boolean
+    %t22 = load_input "x" :: integer
+    %t24 = call core.gt(%t22, %t20) :: boolean
+    %t9 = call core.and(%t21, %t24) :: boolean
+    %t10 = const "both positive" :: string
+    %t12 = const "x positive" :: string
+    %t14 = const "y positive" :: string
+    %t15 = const "neither positive" :: string
+    %t16 = select %t21, %t14, %t15 :: string
+    %t17 = select %t24, %t12, %t16 :: string
+    %t18 = select %t9, %t10, %t17 :: string
+    yield %t18
+  )
+)

data/golden/cascade_logic/expected/lir_04_1_loop_fusion.txt

@@ -0,0 +1,30 @@
+(LIR
+  (Declaration y_positive
+    %t1 = load_input "y" :: integer
+    %t2 = const 0 :: integer
+    %t3 = call core.gt(%t1, %t2) :: boolean
+    yield %t3
+  )
+  (Declaration x_positive
+    %t4 = load_input "x" :: integer
+    %t5 = const 0 :: integer
+    %t6 = call core.gt(%t4, %t5) :: boolean
+    yield %t6
+  )
+  (Declaration status
+    %t19 = load_input "y" :: integer
+    %t20 = const 0 :: integer
+    %t21 = call core.gt(%t19, %t20) :: boolean
+    %t22 = load_input "x" :: integer
+    %t24 = call core.gt(%t22, %t20) :: boolean
+    %t9 = call core.and(%t21, %t24) :: boolean
+    %t10 = const "both positive" :: string
+    %t12 = const "x positive" :: string
+    %t14 = const "y positive" :: string
+    %t15 = const "neither positive" :: string
+    %t16 = select %t21, %t14, %t15 :: string
+    %t17 = select %t24, %t12, %t16 :: string
+    %t18 = select %t9, %t10, %t17 :: string
+    yield %t18
+  )
+)

data/golden/cascade_logic/expected/lir_04_loop_invcm.txt

@@ -0,0 +1,30 @@
+(LIR
+  (Declaration y_positive
+    %t1 = load_input "y" :: integer
+    %t2 = const 0 :: integer
+    %t3 = call core.gt(%t1, %t2) :: boolean
+    yield %t3
+  )
+  (Declaration x_positive
+    %t4 = load_input "x" :: integer
+    %t5 = const 0 :: integer
+    %t6 = call core.gt(%t4, %t5) :: boolean
+    yield %t6
+  )
+  (Declaration status
+    %t19 = load_input "y" :: integer
+    %t20 = const 0 :: integer
+    %t21 = call core.gt(%t19, %t20) :: boolean
+    %t22 = load_input "x" :: integer
+    %t24 = call core.gt(%t22, %t20) :: boolean
+    %t9 = call core.and(%t21, %t24) :: boolean
+    %t10 = const "both positive" :: string
+    %t12 = const "x positive" :: string
+    %t14 = const "y positive" :: string
+    %t15 = const "neither positive" :: string
+    %t16 = select %t21, %t14, %t15 :: string
+    %t17 = select %t24, %t12, %t16 :: string
+    %t18 = select %t9, %t10, %t17 :: string
+    yield %t18
+  )
+)

data/golden/cascade_logic/expected/lir_06_const_prop.txt

@@ -0,0 +1,30 @@
+(LIR
+  (Declaration y_positive
+    %t1 = load_input "y" :: integer
+    %t2 = const 0 :: integer
+    %t3 = call core.gt(%t1, %t2) :: boolean
+    yield %t3
+  )
+  (Declaration x_positive
+    %t4 = load_input "x" :: integer
+    %t5 = const 0 :: integer
+    %t6 = call core.gt(%t4, %t5) :: boolean
+    yield %t6
+  )
+  (Declaration status
+    %t19 = load_input "y" :: integer
+    %t20 = const 0 :: integer
+    %t21 = call core.gt(%t19, %t20) :: boolean
+    %t22 = load_input "x" :: integer
+    %t24 = call core.gt(%t22, %t20) :: boolean
+    %t9 = call core.and(%t21, %t24) :: boolean
+    %t10 = const "both positive" :: string
+    %t12 = const "x positive" :: string
+    %t14 = const "y positive" :: string
+    %t15 = const "neither positive" :: string
+    %t16 = select %t21, %t14, %t15 :: string
+    %t17 = select %t24, %t12, %t16 :: string
+    %t18 = select %t9, %t10, %t17 :: string
+    yield %t18
+  )
+)

data/golden/cascade_logic/expected/nast.txt

@@ -0,0 +1,32 @@
+(NAST
+  (TRAIT y_positive
+    (Call :"core.gt"
+    (InputRef [:y])
+    (Const 0)
+  )
+  )
+  (TRAIT x_positive
+    (Call :"core.gt"
+    (InputRef [:x])
+    (Const 0)
+  )
+  )
+  (VALUE status
+    (Call :__select__
+    (Call :"core.and"
+      (Ref y_positive)
+      (Ref x_positive)
+    )
+    (Const "both positive")
+    (Call :__select__
+      (Ref x_positive)
+      (Const "x positive")
+      (Call :__select__
+        (Ref y_positive)
+        (Const "y positive")
+        (Const "neither positive")
+      )
+    )
+  )
+  )
+)

data/golden/cascade_logic/expected/schema_javascript.mjs

@@ -0,0 +1,31 @@
+export function _y_positive(input) {
+  let t1 = input["y"];
+  const t2 = 0;
+  let t3 = t1 > t2;
+  return t3;
+}
+
+export function _x_positive(input) {
+  let t4 = input["x"];
+  const t5 = 0;
+  let t6 = t4 > t5;
+  return t6;
+}
+
+export function _status(input) {
+  let t19 = input["y"];
+  const t20 = 0;
+  let t21 = t19 > t20;
+  let t22 = input["x"];
+  let t24 = t22 > t20;
+  let t9 = t21 && t24;
+  const t10 = "both positive";
+  const t12 = "x positive";
+  const t14 = "y positive";
+  const t15 = "neither positive";
+  let t16 = t21 ? t14 : t15;
+  let t17 = t24 ? t12 : t16;
+  let t18 = t9 ? t10 : t17;
+  return t18;
+}
+

data/golden/cascade_logic/expected/schema_ruby.rb

@@ -0,0 +1,57 @@
+# Autogenerated by Kumi Codegen
+module Kumi::Compiled::KUMI_224cfbaaefdfa09e4554f97c92feefff11d3f31eb69c5be7d4e017cf7895cf77
+  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 :y_positive then _y_positive
+    when :x_positive then _x_positive
+    when :status then _status
+    else raise KeyError, "Unknown declaration"
+    end
+  end
+
+  def _y_positive(input = @input)
+    t1 = input["y"] || input[:y]
+    t2 = 0
+    t1 > t2
+  end
+
+  def _x_positive(input = @input)
+    t4 = input["x"] || input[:x]
+    t5 = 0
+    t4 > t5
+  end
+
+  def _status(input = @input)
+    t19 = input["y"] || input[:y]
+    t20 = 0
+    t21 = t19 > t20
+    t22 = input["x"] || input[:x]
+    t24 = t22 > t20
+    t9 = t21 && t24
+    t10 = "both positive"
+    t12 = "x positive"
+    t14 = "y positive"
+    t15 = "neither positive"
+    t16 = t21 ? t14 : t15
+    t17 = t24 ? t12 : t16
+    t9 ? t10 : t17
+  end
+end

data/golden/cascade_logic/expected/snast.txt

@@ -0,0 +1,32 @@
+(SNAST
+  (TRAIT y_positive
+    (Call :core.gt
+      (InputRef y key_chain=[]) :: [] -> integer
+      (Const 0) :: [] -> integer
+    ) :: [] -> boolean
+  ) :: [] -> boolean
+  (TRAIT x_positive
+    (Call :core.gt
+      (InputRef x key_chain=[]) :: [] -> integer
+      (Const 0) :: [] -> integer
+    ) :: [] -> boolean
+  ) :: [] -> boolean
+  (VALUE status
+    (Select
+      (Call :core.and
+        (Ref y_positive) :: [] -> boolean
+        (Ref x_positive) :: [] -> boolean
+      ) :: [] -> boolean
+      (Const "both positive") :: [] -> string
+      (Select
+        (Ref x_positive) :: [] -> boolean
+        (Const "x positive") :: [] -> string
+        (Select
+          (Ref y_positive) :: [] -> boolean
+          (Const "y positive") :: [] -> string
+          (Const "neither positive") :: [] -> string
+        ) :: [] -> string
+      ) :: [] -> string
+    ) :: [] -> string
+  ) :: [] -> string
+)

data/golden/cascade_logic/expected.json

@@ -0,0 +1,5 @@
+{
+  "status": "x positive",
+  "x_positive": true,
+  "y_positive": false
+}

data/golden/cascade_logic/input.json

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

data/golden/cascade_logic/schema.kumi

@@ -7,10 +7,8 @@ schema do
   trait :x_positive, input.x > 0
   trait :y_positive, input.y > 0
 
-  trait :both_positive, y_positive & x_positive
-  
   value :status do
-    on both_positive, "both positive"
+    on y_positive, x_positive, "both positive"
     on x_positive, "x positive"  
     on y_positive, "y positive"
     base "neither positive"