I am having problems coming up with nice combinators for a simple DSEL. The abstract syntax is simply given by the types: data SearchCondition = SearchCondition BoolTerm | OpOr SearchCondition BoolTerm data BoolTerm = BoolTerm BoolFactor | OpAnd BoolTerm BoolFactor data BoolFactor = Constant Bool My current combinators are (.||.) :: SearchCondition -> BoolTerm -> SearchCondition (.||.) sc term = OpOr sc term (.&&.) :: BoolTerm -> BoolFactor -> BoolTerm (.&&.) term fact = OpAnd term fact which allow you to write expression of the form factTrue = Constant True termTrue = BoolTerm factTrue scTrue = SearchCondition termTrue sc = scTrue .||. termTrue .||. termTrue .&&. factTrue I am wondering it it is possible to define combinators to hide the structure of the grammar from the user to some extent, so that the user can simply write things like sc = True .||.True .||. True .&&. False or sc = const True .||. const True .||. const True .&&. const False That is the user does not have to worry about the distinction between terms and factors (which exists solely for precedence in this case). Or is it a better idea to just remove the precedence rules from the types and move it the part of the code that evaluates the expressions? Rahul