associativity

I am having trouble understanding the concept of associativity in the context of ternary operators. In most cases, ternary operators look like this: a ? b : c In this case, no associativity is needed to evaluate the expression. Sometimes though, Ternary Operators are nested: a ? b : c ? d : e a ? b : (c ? d : e) // : is right-associative However, the nesting could also be inverted a ? b ? c : d : e a ? (b ? c : d) : e // : is left-associative What is the best way to explain this phenomenon? Could you consider the associativity of the : operator to be context-dependant, or am I missing

Say I have an expression as follows (where ⨁ and ⨂ are binary operators which have the same precedence level but not the same associativity): x ⨁ y ⨂ z Would y belong to ⨁ or ⨂ , and based on what criteria? According to the Edsgar Dijkstra's Shunting-yard algorithm if neighboring two operators in an expressions have the same precedence level then the expression is disambiguated based on the associativity of the second operator. If the second operator is left associative then the operand belongs to the first operator. If the second operator is right associative then the operand belongs to the

For an associative operation f over the elements of array a , the following relation should hold true: a.reduce(f) should be equivalent to a.reduceRight(f) . Indeed, it does hold true for operations that are both associative and commutative. For example: var a = [1,2,3,4,5,6,7,8,9,0]; alert(a.reduce(add) === a.reduceRight(add)); function add(a, b) { return a + b; } However it doesn't hold true for operations that are associative but not commutative. For example: var a = [[1,2],[3,4],[5,6],[7,8],[9,0]]; alert(equals(a.reduce(concat), a.reduceRight(concat))); function concat(a, b) { return a

I'm trying to prove that type-level function Union is associative, but I'm not sure how it should be done. I proved right identity and associativity laws for type-level append function and right identity for union: data SList (i :: [k]) where SNil :: SList '[] SSucc :: SList t -> SList (h ': t) appRightId :: SList xs -> xs :~: (xs :++ '[]) appRightId SNil = Refl appRightId (SSucc xs) = case appRightId xs of Refl -> Refl appAssoc :: SList xs -> Proxy ys -> Proxy zs -> (xs :++ (ys :++ zs)) :~: ((xs :++ ys) :++ zs) appAssoc SNil _ _ = Refl appAssoc (SSucc xs) ys zs = case appAssoc xs ys zs of