What is the preferred alternative to Fin from Idris in Haskell

前端 未结 2 2120
我在风中等你
我在风中等你 2021-02-20 06:20

I would like to have a type which can contain values 0 to n, where n lives on the type level.

I was trying something like:

import GHC.TypeLits
import Da         


        
相关标签:
2条回答
  • 2021-02-20 07:15

    You can directly translate Idris's Fin into the usual Haskell mishmash of sort-of-dependently-typed features.

    data Fin n where
        FZ :: Fin (S n)
        FS :: Fin n -> Fin (S n)
    
    (!) :: Vec n a -> Fin n -> a
    (x :> xs) ! FZ = x
    (x :> xs) ! (FS f) = xs ! f
    

    With TypeInType you can even have singleton Fins!

    data Finny n (f :: Fin n) where
        FZy :: Finny (S n) FZ
        FSy :: Finny n f -> Finny (S n) (FS f)
    

    This allows you to fake up dependent quantification over runtime stuff, eg,

    type family Fin2Nat n (f :: Fin n) where
        Fin2Nat (S _) FZ = Z
        Fin2Nat (S n) (FS f) = S (Fin2Nat n f)
    
    -- tighten the upper bound on a given Fin as far as possible
    tighten :: Finny n f -> Fin (S (Fin2Nat n f))
    tighten FZy = FZ
    tighten (FSy f) = FS (tighten f)
    

    but, ugh, it kinda sucks to have to duplicate everything at the value and type level, and writing out all your kind variables (n) can get pretty tedious.


    If you're really sure you need an efficient runtime representation of Fin, you can do basically what you did in your question: stuff a machine Int into a newtype and use a phantom type for its size. But the onus is on you, the library implementer, to make sure the Int fits the bound!

    newtype Fin n = Fin Int
    
    -- fake up the constructors
    fz :: Fin (S n)
    fz = Fin 0
    fs :: Fin n -> Fin (S n)
    fs (Fin n) = Fin (n+1)
    

    This version lacks real GADT constructors, so you can't manipulate type equalities using pattern matching. You have to do it yourself using unsafeCoerce. You can give clients a type-safe interface in the form of fold, but they have to be willing to write all their code in a higher-order style, and (since fold is a catamorphism) it becomes harder to look at more than one layer at a time.

    -- the unsafeCoerce calls assert that m ~ S n
    fold :: (forall n. r n -> r (S n)) -> (forall n. r (S n)) -> Fin m -> r m
    fold k z (Fin 0) = unsafeCoerce z
    fold k z (Fin n) = unsafeCoerce $ k $ fold k z (Fin (n-1))
    

    Oh, and you can't do type level computation (as we did with Fin2Nat above) with this representation of Fin, because type level Ints don't permit induction.

    For what it's worth, Idris's Fin is just as inefficient as the GADT one above. The docs contain the following caveat:

    It's probably not a good idea to use Fin for arithmetic, and they will be exceedingly inefficient at run time.

    I've heard noises about a future version of Idris being able to spot "Nat with types"-style datatypes (like Fin) and automatically erase the proofs and pack the values into machine integers, but as far as I know we're not there yet.

    0 讨论(0)
  • 2021-02-20 07:16

    rampion suggested pattern synonyms, and I agreed, but it is admittedly not entirely trivial to work out how to structure their signatures properly. Thus I figured I'd write a proper answer to give the full code.

    First, the usual boilerplate:

    {-# LANGUAGE DataKinds #-}
    {-# LANGUAGE PatternSynonyms #-}
    {-# LANGUAGE ScopedTypeVariables #-}
    {-# LANGUAGE GADTs #-}
    {-# LANGUAGE KindSignatures #-}
    {-# LANGUAGE ViewPatterns #-}
    {-# LANGUAGE StandaloneDeriving #-}
    {-# LANGUAGE Trustworthy #-}
    
    module FakeFin (Nat (..), Fin (FZ, FS), FinView (..), viewFin) where
    import Numeric.Natural
    import Unsafe.Coerce
    

    Now the basic types:

    data Nat = Z | S Nat
    
    -- Fin *must* be exported abstractly (or placed in an Unsafe
    -- module). Users can use its constructor to implement
    -- unsafeCoerce!
    newtype Fin (n :: Nat) = Fin Natural
    deriving instance Show (Fin n)
    

    It is much easier to work via a view type rather than directly, so let's define one:

    data FinView n where
      VZ :: FinView ('S n)
      VS :: !(Fin n) -> FinView ('S n)
    deriving instance Show (FinView n)
    

    It is important to note that we could have defined FinView using explicit equality constraints, because we will have to think in those terms to give correct pattern signatures:

    data FinView n where
      VZ :: n ~ 'S m => FinView n
      VS :: n ~ 'S m => !(Fin m) -> FinView n
    

    Now the actual view function:

    viewFin :: Fin n -> FinView n
    viewFin (Fin 0) = unsafeCoerce VZ
    viewFin (Fin n) = unsafeCoerce (VS (Fin (n - 1)))
    

    The pattern signatures precisely mirror the signatures of the FinView constructors.

    pattern FZ :: () => n ~ 'S m => Fin n
    pattern FZ <- (viewFin -> VZ) where
      FZ = Fin 0
    
    pattern FS :: () => n ~ 'S m => Fin m -> Fin n
    pattern FS m <- (viewFin -> VS m) where
      FS (Fin m) = Fin (1 + m)
    
    -- Let GHC know that users need only match on `FZ` and `FS`.
    -- This pragma only works for GHC 8.2 (and presumably future
    -- versions).
    {-# COMPLETE FZ, FS #-}
    

    For completeness (because it took me rather more effort to write this than I expected), here's one way to write unsafeCoerce if this module accidentally exports the Fin data constructor. I imagine there are probably simpler ways.

    import Data.Type.Equality
    
    type family YahF n a b where
      YahF 'Z a _ = a
      YahF _ _ b = b
    
    newtype Yah n a b = Yah (YahF n a b)
    
    {-# NOINLINE finZBad #-}
    finZBad :: 'Z :~: n -> Fin n -> a -> b
    finZBad pf q =
      case q of
        FZ -> blah (trans pf Refl)
        FS _ -> blah (trans pf Refl)
      where
        blah :: forall a b m. 'Z :~: 'S m -> a -> b
        blah pf2 a = getB pf2 (Yah a)
    
        {-# NOINLINE getB #-}
        getB :: n :~: 'S m -> Yah n a b -> b
        getB Refl (Yah b) = b
    
    myUnsafeCoerce :: a -> b
    myUnsafeCoerce = finZBad Refl (Fin 0)
    

    finZBad is where all the action happens, but it doesn't do anything remotely improper! If someone really gives us a non-bottom value of type Fin 'Z, then something has already gone terribly wrong. The explicit type equality evidence here is necessary because if GHC sees code wanting 'Z ~ 'S m, it will simply reject it out of hand; GHC doesn't really like hypothetical reasoning in constraints. The NOINLINE annotations are necessary because GHC's simplifier itself uses type information; handling evidence of things it knows very well are impossible confuses it terribly, with extremely arbitrary results. So we block it up and successfully implement The Evil Function.

    0 讨论(0)
提交回复
热议问题