View source for Comparison chain

== Problem ==

Question:
The compiler doesn't accept <hask>a <= x <= b</hask>. Why?

Answer:
The expression cannot be parsed, because the infix symbol <hask> <= </hask> has no (left or right) associativity.

In languages like C
the expression is parsed as <code>(a <= x) <= b</code> which is even worse.
The first part is evaluated to a boolean value,
which is then compared with <code>b</code>.
(For C "boolean" and "integer" are the same type.)

== Solutions ==

=== simple ===

* You must be aware, that the mathematical notation <math>a \le x \le b</math> is shorthand for <math>a \le x\ \land\ x \le b</math>. Consequently a possible Haskell solution is <hask>a <= x && x <= b</hask>.
* Another fine mathematical notation is <math>x \in [a,b]</math>. You can roll your own function
:
<haskell>
isInRange :: Ord a => a -> a -> a -> Bool
isInRange lower upper x = lower <= x && x <= upper
</haskell>
:to capture this notation (<hask>isInRange a b x</hask>), or
:
<haskell>
(<?) :: Ord a => a -> (a,a) -> Bool
(<?) = flip (uncurry isInRange)
</haskell>
:(<hask>x <? (a,b)</hask>). In case of integers you can use the <hask>inRange</hask> function from <hask>Ix</hask> class.
* You can easily write a function, which checks if a list of numbers increases monotonically.
:
<haskell>
monotonicIncreasing :: Ord a => [a] -> Bool
monotonicIncreasing xs = and (zipWith (<=) xs (tail xs))
</haskell>
: You can use that for the initial problem by <hask>monotonicIncreasing [a,x,b]</hask>.


=== complex ===

* For more complex checks of whether an element is contained in some ranges, you should have a look at the [[Libraries_and_tools/Mathematics#other|ranged sets]] library.
* If you want to program more complex chains with different kinds of comparisons, try the following [http://darcs.haskell.org/htam/src/ChainComparison.hs code].

<haskell>
module ChainRelation where

{- * chains of relations (comparison, subsets, logical implications etc.) -}

infixr 4 &-, -&

type Rel   a = (a -> a -> Bool)
type Chain a = [(Rel a, a)]

endChain :: Chain a
endChain = []

-- separate comparison and operand
(&-) :: Rel a -> (a, Chain a) -> Chain a
rel &- (x,xs) = (rel,x):xs

-- separate operand and comparison
(-&) :: a -> Chain a -> (a, Chain a)
(-&) = (,)

-- check if all comparisons are true
check :: (a, Chain a) -> Bool
check (x,chain) =
   let (rels,xs) = unzip chain
   in  and (zipWith3 id rels (x:xs) xs)


example1 :: Bool
example1 =
   check (1 -& (<) &- 5 -& (==) &- 5 -& (<=) &- 10 -&
      (endChain :: Chain Integer))


{- * specialised infix operators for comparison -}

infixr 4 ==:, /=:, <:, >:, <=:, >=:

(==:), (/=:), (<:), (>:), (<=:), (>=:) :: Ord a =>
   a -> (a, Chain a) -> (a, Chain a)
(==:) = lift (==)
(/=:) = lift (/=)
(<:)  = lift (<)
(>:)  = lift (>)
(<=:) = lift (<=)
(>=:) = lift (>=)

lift :: Rel a -> a -> (a, Chain a) -> (a, Chain a)
lift f x (y,chain) = (x, (f,y):chain)

example2 :: Bool
example2 =
   check (1 <: 5 ==: 5 <=: 10
             -& (endChain :: Chain Integer))
</haskell>

* You can represent a successful sequence of comparisons with <code>Just a</code> and a failed sequence with <code>Nothing</code>:

<haskell>
module ChainRelation2 where

import Data.Maybe (isJust)

lift :: (a -> b -> Bool) -> Maybe a -> b -> Maybe b
lift f (Just x) y | f x y = Just y
lift _ _ _ = Nothing

(<:)  = lift (<)
(<=:) = lift (<=)
(*:)  = lift elem

example = isJust (Just 4 <: 5 <=: 6 *: [6,7])

-- Python equivalent: 4 < 5 <= 6 in [6,7]
</haskell>

[[Category:Mathematics]]
[[Category:FAQ]]
[[Category:Idioms]]
[[Category:Code]]