various fixes

Author: drblallo

lib/conversions/src/RLCToPython.cpp

@@ -171,9 +171,9 @@ namespace mlir::rlc
 
 		if (returnsVoid(type).failed())
 		{
-			w.write("__result = ");
+			w.write("__result = (");
 			w.writeType(resultType, 1);
-			w.writenl("()");
+			w.writenl(")()");
 		}
 
 		w.write("lib.", mangledName);

lib/dialect/src/TypeCheck.cpp

@@ -274,7 +274,7 @@ static mlir::LogicalResult deduceClassBody(
 		auto checkedParameterType = scopedConverter.convertType(unchecked);
 		if (not checkedParameterType)
 		{
-			return mlir::failure();
+			return mlir::rlc::logError(op, "While analyzing class declaration, could not understand the semantics of " + mlir::rlc::prettyType(unchecked)) ;
 		}
 		checkedTemplateParameters.push_back(checkedParameterType);
 		auto actualType =

lib/dialect/src/Types.cpp

@@ -500,6 +500,11 @@ namespace mlir::rlc
 			OS << maybeType.getName();
 			return;
 		}
+		if (auto maybeType = mlir::dyn_cast<mlir::rlc::UncheckedTemplateParameterType>(t))
+		{
+			OS << "unchecked_" <<maybeType.getName();
+			return;
+		}
 		if (auto maybeType = mlir::dyn_cast<mlir::rlc::ContextType>(t))
 		{
 			typeToMangled(OS, maybeType.getUnderlying());

python/ml/ppg/torch_util.py

@@ -120,10 +120,16 @@ def have_cuda():
         and th.cuda.device_count() > 0
     )
 
+def have_mps():
+    return (th.backends.mps.is_available())
 
 def default_device_type():
-    return "cuda" if have_cuda() else "cpu"
-
+    if have_cuda():
+        return "cuda"
+    elif have_mps():
+        return "mps"
+    else:
+        return "cpu"
 
 no_grad = contextmanager_to_decorator(th.no_grad)
 DEFAULT_DEVICE = th.device(type=default_device_type())

stdlib/enum_utils.rl

@@ -15,8 +15,26 @@
 #
 
 trait<T> Enum:
-    fun max(T obj) -> Int
-    fun is_enum(T obj) -> Bool 
-    fun as_int(T obj) -> Int
-    fun from_int(T obj, Int new_value)
-    fun as_string_literal(T obj) -> StringLiteral
+  fun max(T obj) -> Int
+  fun is_enum(T obj) -> Bool
+  fun as_int(T obj) -> Int
+  fun from_int(T obj, Int new_value)
+  fun as_string_literal(T obj) -> StringLiteral
+
+cls<T> EnumRange:
+  fun get(Int x) -> T:
+    let to_return : T
+    if to_return is Enum:
+      from_int(to_return, x)
+    return to_return
+
+  fun size() -> Int:
+    let to_return : T
+    if to_return is Enum:
+      return max(to_return) + 1
+    return 0
+
+fun<Enum T> range(T t) -> EnumRange<T>:
+  let to_return : EnumRange<T>
+  return to_return
+

stdlib/math/numeric.rl

@@ -27,6 +27,10 @@ fun min(Int a, Int b) -> Int:
 ext fun sqrt(Float f) -> Float
 
 fun abs(Int a) -> Int:
-    if 0 > a:
-        return -a
-    return a
+  if 0 > a:
+    return -a
+  return a
+
+fun near(Float value, Float target, Float distance) -> Bool:
+  return target + distance > value and target - distance < value
+

tool/rlc/test/wrappers/return_array_wrapper.rl

@@ -0,0 +1,17 @@
+# RUN: split-file %s %t
+# RUN: rlc %t/source.rl -o %t/lib%sharedext -i %stdlib --shared --pyrlc-lib=%pyrlc_lib
+# RUN: rlc %t/source.rl -o %t/wrapper.py -i %stdlib --python
+# RUN: python %t/to_run.py
+
+#--- source.rl
+
+fun asd() -> Int[10]:
+  let x : Int[10]
+  return x
+
+
+#--- to_run.py
+import wrapper
+
+assert len(wrapper.asd()) == 10
+

tool/rlc/test/wrappers/ruby_unions_accessor.rl

@@ -0,0 +1,159 @@
+# REQUIRES: has_ruby
+# RUN: split-file %s %t
+
+# RUN: rlc %t/source.rl -o %t/lib%sharedext -i %stdlib --shared
+# RUN: rlc %t/source.rl -o %t/lib%libext -i %stdlib --compile
+
+# RUN: rlc %t/source.rl -o %t/library.rb -i %stdlib --ruby
+# RUN: ruby %t/to_run.rb
+
+
+#--- source.rl
+import serialization.to_byte_vector
+import string
+import action
+import learn
+
+cls Board:
+  BInt<0, 3>[9] slots
+  Bool playerTurn
+
+  fun get(Int x, Int y) -> Int:
+    return self.slots[x + (y * 3)].value
+
+  fun set(Int x, Int y, Int val):
+    self.slots[x + (y * 3)].value = val
+
+  fun full() -> Bool:
+    let x = 0
+
+    while x < 3:
+      let y = 0
+      while y < 3:
+        if self.get(x, y) == 0:
+          return false
+        y = y + 1
+      x = x + 1
+
+    return true
+
+  fun three_in_a_line_player_row(Int player_id, Int row) -> Bool:
+    return self.get(0, row) == self.get(1, row) and self.get(0, row) == self.get(2, row) and self.get(0, row) == player_id
+
+  fun three_in_a_line_player(Int player_id) -> Bool:
+    let x = 0
+    while x < 3:
+      if self.get(x, 0) == self.get(x, 1) and self.get(x, 0) == self.get(x, 2) and self.get(x, 0) == player_id:
+        return true
+
+      if self.three_in_a_line_player_row(player_id, x):
+        return true
+      x = x + 1
+
+    if self.get(0, 0) == self.get(1, 1) and self.get(0, 0) == self.get(2, 2) and self.get(0, 0) == player_id:
+      return true
+
+    if self.get(0, 2) == self.get(1, 1) and self.get(0, 2) == self.get(2, 0) and self.get(0, 2) == player_id:
+      return true
+
+    return false
+
+  fun current_player() -> Int:
+    return int(self.playerTurn) + 1
+
+  fun next_turn():
+    self.playerTurn = !self.playerTurn
+
+# tic tac toe implementation
+
+@classes
+act play() -> Game:
+  frm board : Board
+  frm score = 10
+  while !board.full():
+    # sets the indicated board as beloning 
+    # to the current player
+    act mark(BInt<0, 3> x, BInt<0, 3> y) { board.get(x.value, y.value) == 0 }
+
+    score = score - 1
+    board.set(x.value, y.value, board.current_player())
+
+    if board.three_in_a_line_player(board.current_player()):
+      return
+    board.next_turn()
+
+fun get_current_player(Game g) -> Int:
+  return int(g.board.playerTurn)
+
+fun score(Game g, Int player_id) -> Float:
+  if !g.is_done():
+    return 0.0
+  if g.board.three_in_a_line_player(player_id + 1):
+    return 1.0
+  else if g.board.three_in_a_line_player(((player_id + 1) % 2) + 1):
+    return -1.0
+
+  return 0.0
+
+fun get_num_players() -> Int:
+  return 2
+
+fun fuzz(Vector<Byte> input):
+  if input.size() == 0:
+    return
+  let state = play()
+  let action : AnyGameAction
+  parse_and_execute(state, action, input)
+
+fun main() -> Int:
+  let game = play()
+  let x : BInt<0, 3>
+  let y : BInt<0, 3>
+  x.value = 0
+  y.value = 0
+  game.mark(x, y)
+  if game.board.full():
+    return 1
+  x.value = 1
+  y.value = 0
+  game.mark(x, y)
+  if game.board.full():
+    return 2
+  x.value = 1
+  y.value = 1
+  game.mark(x, y)
+  if game.board.full():
+    return 3
+  x.value = 2
+  y.value = 0
+  game.mark(x, y)
+  if game.board.full():
+    return 4
+  x.value = 2
+  y.value = 2
+  game.mark(x, y)
+  if game.board.full():
+    return 5
+  if game.board.three_in_a_line_player(1):
+    return 0
+  else:
+    return 1
+
+fun pretty_print(Game g):
+  let i = 0
+  while i != 3:
+    let to_print : String
+    let y = 0
+    while y != 3:
+      to_print.append(to_string(g.board.get(i, y)))
+      y = y + 1
+    print(to_print)
+    i = i + 1
+#--- to_run.rb
+require_relative 'library'
+action = RLC::RLCAnyGameAction.new
+_actions = RLC::enumerate(action)
+print(_actions)
+actions = (0..._actions.size).map { |i| _actions.get(i) }
+action = actions[0]
+puts(action[0])

tool/rlc/test/wrappers/test_trace_runner.rl

@@ -0,0 +1,25 @@
+# RUN: split-file %s %t 
+# RUN: python %pyscript/action.py %t/source.rl %t/trace.txt --stdlib %stdlib -ii | FileCheck %s
+
+# CHECK: asd {x: 4} 
+# CHECK-NEXT: asd2 {y: {field: 5}}
+# CHECK-NEXT: asd3 {}
+# CHECK-NEXT: {resume_index: -1}
+
+#--- source.rl
+import action
+
+cls Struct:
+    Int field
+
+@classes
+act play() -> Game:
+    act asd(Int x) {x == 4}
+    act asd2(Struct y) {y.field == 5}
+    act asd3()
+
+#--- trace.txt
+asd {x: 4}
+asd2 {y: {field: 5}}
+asd {x: 10}
+asd3 {}