为什么haskell中没有间隔类型类？

1 回答

• 0

  您可以使用-XFunctionalDependences和 -XFlexibleInstances 执行此操作（使用此编写任何实例...） . 我在下面写了一些代码和评论来说明：

  {-# LANGUAGE FlexibleInstances      #-}
  {-# LANGUAGE FunctionalDependencies #-}
  
  -- | Intervals with endpoints of type e.
  class (Ord e) => Interval i e | i -> e where
    {-# MINIMAL inf, sup #-}
    -- lower bound ("infinimum") 
    inf :: i -> e
    -- upper bound ("supremum")
    sup :: i -> e
  
  -- Is (X : Interval e) a valid Interval?
  valid :: Interval i e => i -> Bool
  valid x = sup x > inf x
  
  -- Is (X : Interval e) an invalid Interval?
  notValid :: Interval i e => i -> Bool
  notValid = not . valid
  
  -- Is (x : e) contained within (X : Interval e)
  containsPoint :: Interval i e => i -> e -> Bool
  x `containsPoint` p = p >= inf x && p <= sup x
  
  -- Is (x : e) below (X : Interval e)
  abovePoint :: Interval i e => i -> e -> Bool
  x `abovePoint` p = p < inf x
  
  -- Is (x : e) above (X : Interval e)
  belowPoint :: Interval i e => i -> e -> Bool
  x `belowPoint` p = p > sup x
  
  -- For all (x : e) in (X : Interval e), (y : e) in (Y : Interval e),
  -- x < y iff sup X < inf Y 
  before :: Interval i e => i -> i -> Bool
  x `before` y = sup x < inf y
  
  -- For all (x : e) in (X : Interval e), (y : e) in (Y : Interval e),
  -- x > y iff inf X > sup Y 
  after :: Interval i e => i -> i -> Bool
  x `after` y = inf x > sup y
  
  -- For all (x : e) in (X : Interval e), (y : e) in (Y : Interval e),
  -- x == y iff (inf X == inf Y) && (sup X == sup Y)
  equals :: Interval i e => i -> i -> Bool
  x `equals` y = inf x == inf y && sup x == sup y
  
  -- For all (x : e) in (X : Interval e), (y : e) in (Y : Interval e),
  -- x /= y iff (sup x < inf y) || (inf x > sup y)
  nequals :: Interval i e => i -> i -> Bool
  x `nequals` y = sup x < inf y || inf x > sup y
  
  -- For all (x : e) in (X : Interval e), (y : e) in (Y : Interval e),
  -- x <= y iff sup x <= inf y
  eqBefore :: Interval i e => i -> i -> Bool
  x `eqBefore` y = sup x <= inf y
  
  -- For all (x : e) in (X : Interval e), (y : e) in (Y : Interval e),
  -- x >= y iff inf x >= sup y
  eqAfter :: Interval i e => i -> i -> Bool
  x `eqAfter` y = inf x >= sup y
  
  -- Does (X : Interval e) contain (Y : Interval e)?
  contains :: Interval i e => i -> i -> Bool
  x `contains` y = inf x <= inf y && sup y <= sup x
  
  -- Is (X : Interval e) a subset of (Y : Interval e)?
  isSubSetOf :: Interval i e => i -> i -> Bool
  isSubSetOf = flip contains
  
  -- Do (X : Interval e) and (Y : Interval e) overlap?
  overlaps :: Interval i e => i -> i -> Bool 
  x `overlaps` y = inf x <= sup y && sup x >= inf y
  
  instance (Ord e) => Interval (e,e) e where
    inf (a,_) = a
    sup (_,b) = b
  
  instance (Ord a) => Interval [a] a where
    inf = minimum
    sup = maximum
  
  main :: IO ()
  main = do
    putStrLn $ inf ["one","two","three"] -- will print "one"
    putStrLn $ sup ("first","second")    -- will print "second"
  

  但是，正如评论者指出的那样，这是非常不必要的 . 有一个像 Interval 数据类型的东西可能更好，只有 Interval Double ， Interval Int 等 . 我推荐intervals包 .

  回复于 2024-04-29T11:56:33+08:00