Hi everybody,
I'm still working on implementing a nomic game in Haskell.
Although the game is pretty advanced, I'm still confused by one fundamental question:
A nomic game is composed of rules.
A Rule is a sort of little program submitted by the player during the game. They come in two fashions:
- a Normal rule, when executed, can change the state of the Game.
- a Meta rule, when executed on another rule, can assess the legality of that rule and change the state of the Game.

In those definitions, the Game can be seen as a data structure containing all the current state of the game. Sorry if it's a bit abstract, but as it's fairly complex,
I'd prefer to keep it like this for the moment.
Thus, I found that those definitions can be translated to two possible type definitions:

type NormalRule = State Game ()
type MetaRule = Rule -> State Game Bool
data Rule = MR MetaRule | NR NormalRule

*** or ***

newtype Rule = Rule {rule :: Maybe Rule -> (State Game Bool)}

All rules submitted by the user must be of the type Rule. It is thus important that it is very clean.
Which type do you prefer?
I find both heavy and redundant. The first forces me to specify if I want an argument of not (with the constructors MR and NR), the second forces me to pass the Nothing argument in the case of a Normal rule, and to return a dummy value (for ex. return True).
Do you know of a construction/abstraction that allows having or not an argument (a variable number of arguments, here zero or one)?

Thanks!
Corentin