Constraint Logic

[ghost]

I looked what we have and saw we only have type union and generics. However we need more logical operations on constraints i think:

• And
• Not
• Or
• Xor
• ...

I thought a way to do: (...) -> constraint-quotes

For examples:

( symbol react
 ( ( (1 2 3) or ) :signal ==> string :reaction)
 (...)
) ::

( symbol int-xor-float
 ( ( (int floatic-int) xor ) :value ==>)
 (value succ puts!)
) ::

( symbol i-want-pi
 ( ( (int pi) or ) :value ==>)
 (value puts!)
) ::

( symbol i-want-only-one
 ( (1) :value ==>)
 (value puts!)
) ::

...

[ghost]

Did you take a look that? What do you think about it? Not good? or good?

[h3rald]

That's what I meant... with DeMorgan laws you can rewrite all rules without using parenthesis. It will be more tedious but hopefully you won't need very complex rules (and at worst you can still create a type class).

Yeah I was going to go for ! for not.

So basically, the algorithm used to parse the type expressions (min parses would still consider them as a single symbol, that's why you can't use spaces) would be:

1. Split by &
2. Process each group and stop when any fails:
   1. Split by |
   2. Process each group and stop when any succeeds
      1. Validate each type. Negate result if ! precedes the type symbol

As for values... unfortunately I am afraid you will have to create typeclasses for those: numbers would be ok (kind of) but strings would probably cause the min parser interfere and split the type expression incorrectly.

[ghost]

That's what I meant... with DeMorgan laws you can rewrite all rules without using parenthesis. It will be more tedious but hopefully you won't need very complex rules (and at worst you can still create a type class).

Yeah I was going to go for ! for not.

So basically, the algorithm used to parse the type expressions (min parses would still consider them as a single symbol, that's why you can't use spaces) would be:

1. Split by &

2. Process each group and stop when any fails:

   1. Split by |

   2. Process each group and stop when any succeeds

      1. Validate each type. Negate result if ! precedes the type symbol

The algorithm and... everything seems okay! 👍

As for values... unfortunately I am afraid you will have to create typeclasses for those: numbers would be ok (kind of) but strings would probably cause the min parser interfere and split the type expression incorrectly.

Log symbols oftenly use numbers for log the state. So please only implement numbers(or anything proper like numbers) as values(others ... hopely not needed).

[h3rald]

Alright. Let's try with integers only 😊👍

[h3rald]

OK I implemented & and ! support as well and it seems to work.

I didn't add integers yet, because I am still a bit skeptical about it: once you add integers then you probably want floats, strings etc... I don't want to rewrite the min parser for type expressions. Let's see how useful Boolean logic with types and typeclasses is first!

[ghost]

OK I implemented & and ! support as well and it seems to work.

Thanks for implementing!

Let's see how useful Boolean logic with types and typeclasses is first!

Yes.