Add support for evaluating BOOL and introduce basic logical operators as functions

smnp/library/loader.py

@@ -4,6 +4,8 @@ from smnp.program.interpreter import Interpreter
 
 
 def loadStandardLibrary():
-    source = resource_string('smnp.library.code', 'main.mus').decode("utf-8")
-    return Interpreter.interpretString(source)
+    mainSource = resource_string('smnp.library.code', 'main.mus').decode("utf-8")
+    boolSource = resource_string('smnp.library.code', 'bool.mus').decode("utf-8")
+    env = Interpreter.interpretString(mainSource)
+    return Interpreter.interpretString(boolSource, baseEnvironment=env)
 

smnp/module/iterable/function/get.py

@@ -12,7 +12,7 @@ def _function1(env, list, index):
         raise RuntimeException(f"Attempt to access item which is outside the list", None)
 
 
-_signature2 = signature(ofType(Type.MAP), ofTypes(Type.INTEGER, Type.STRING, Type.NOTE, Type.TYPE))
+_signature2 = signature(ofType(Type.MAP), ofTypes(Type.INTEGER, Type.STRING, Type.NOTE, Type.BOOL, Type.TYPE))
 def _function2(env, map, key):
     try:
         return map.value[key]

smnp/module/iterable/function/map.py

@@ -4,7 +4,7 @@ from smnp.type.model import Type
 from smnp.type.signature.matcher.list import listOfMatchers, listMatches
 from smnp.type.signature.matcher.type import allTypes, ofTypes
 
-_signature1 = varargSignature(listMatches(ofTypes(Type.INTEGER, Type.STRING, Type.NOTE, Type.TYPE), allTypes()))
+_signature1 = varargSignature(listMatches(ofTypes(Type.INTEGER, Type.STRING, Type.NOTE, Type.BOOL, Type.TYPE), allTypes()))
 def _function1(env, vararg):
     map = {}
     for entry in vararg:
@@ -14,7 +14,7 @@ def _function1(env, vararg):
     return Type.map(map)
 
 
-_signature2 = signature(listOfMatchers(listMatches(ofTypes(Type.INTEGER, Type.STRING, Type.NOTE, Type.TYPE), allTypes())))
+_signature2 = signature(listOfMatchers(listMatches(ofTypes(Type.INTEGER, Type.STRING, Type.NOTE, Type.BOOL, Type.TYPE), allTypes())))
 def _function2(env, list):
     map = {}
     for entry in list.value:

smnp/runtime/evaluators/bool.py

@@ -0,0 +1,9 @@
+from smnp.runtime.evaluator import Evaluator
+from smnp.type.model import Type
+
+
+class BoolEvaluator(Evaluator):
+
+    @classmethod
+    def evaluator(cls, node, environment):
+        return Type.bool(node.value)

smnp/runtime/evaluators/expression.py

@@ -1,6 +1,7 @@
 from smnp.ast.node.access import AccessNode
 from smnp.ast.node.assignment import AssignmentNode
 from smnp.ast.node.asterisk import AsteriskNode
+from smnp.ast.node.bool import BoolLiteralNode
 from smnp.ast.node.identifier import IdentifierNode
 from smnp.ast.node.integer import IntegerLiteralNode
 from smnp.ast.node.invocation import FunctionCallNode
@@ -28,11 +29,13 @@ def expressionEvaluator(doAssert=False):
             from smnp.runtime.evaluators.asterisk import AsteriskEvaluator
             from smnp.runtime.evaluators.map import MapEvaluator
             from smnp.runtime.evaluators.type import TypeEvaluator
+            from smnp.runtime.evaluators.bool import BoolEvaluator
             result =  Evaluator.oneOf(
                 Evaluator.forNodes(FunctionCallEvaluator.evaluate, FunctionCallNode),
                 Evaluator.forNodes(StringEvaluator.evaluate, StringLiteralNode),
                 Evaluator.forNodes(IntegerEvaluator.evaluate, IntegerLiteralNode),
                 Evaluator.forNodes(NoteEvaluator.evaluate, NoteLiteralNode),
+                Evaluator.forNodes(BoolEvaluator.evaluate, BoolLiteralNode),
                 Evaluator.forNodes(TypeEvaluator.evaluate, TypeNode),
                 Evaluator.forNodes(IdentifierEvaluator.evaluate, IdentifierNode),
                 Evaluator.forNodes(ListEvaluator.evaluate, ListNode),

smnp/type/model.py

@@ -54,6 +54,10 @@ class Type(Enum):
             "dot": Type.string('.' if value.dot else '')
         })
 
+    @staticmethod
+    def bool(value):
+        return Value(Type.BOOL, value, {})
+
     @staticmethod
     def sound(value):
         return Value(Type.SOUND, value, {