Data.Void absurd işlevi Void mantıklı ıssız bir türü olan paket tarafından verilen şu imza vardır:

-- | Since 'Void' values logically don't exist, this witnesses the logical
-- reasoning tool of \"ex falso quodlibet\".
absurd :: Void -> a

Bu karşılık gelen belgelere sözleri, almak için yeterli mantığı biliyorum, 16* *geçerli bir formül önermeleri olarak türleri yazışma, tarafından.

Ne tür pratik programlama problemlerinin bu işlev yararlı olur? ve merak kafam karıştı ne dersiniz: Düşünüyorum ki belki de yararlı bazı durumlarda bir tür-güvenli bir şekilde etraflıca işleme "olamaz" durumlarda, ama bilmiyorum, yeteri kadar pratik kullanım Curry-Howard söyle olsun bu fikir doğru yolda.

EDİT: Örnekler eğer kimseye bağımlı yazılan bir dil şikayet edeceğim . kullanmak isterse Haskell tercihen, ama

Lambda açısından serbest değişkenler tarafından parametrize için bu temsili göz önünde bulundurun. (Bkz Bellegarde ve Kanca 1994, Kuş ve Paterson tarafından kağıtları 1999, Altenkirch ve Reus 1999.)

data Tm a  = Var a
           | Tm a :$ Tm a
           | Lam (Tm (Maybe a))

Kesinlikle bu Functor, yeniden adlandırma kavramı yakalama ve Monad Bir bir yerine koyma fikrini yakalama yapabilirsiniz.

instance Functor Tm where
  fmap rho (Var a)   = Var (rho a)
  fmap rho (f :$ s)  = fmap rho f :$ fmap rho s
  fmap rho (Lam t)   = Lam (fmap (fmap rho) t)

instance Monad Tm where
  return = Var
  Var a     >>= sig  = sig a
  (f :$ s)  >>= sig  = (f >>= sig) :$ (s >>= sig)
  Lam t     >>= sig  = Lam (t >>= maybe (Var Nothing) (fmap Just . sig))

Şimdi düşününkapalışartlar: bu Tm Void sakinleri. Keyfi ücretsiz değişkenler açısından içine kapalı şartları gömmek gerekir. Nasıl?

fmap absurd :: Tm Void -> Tm a

Yakalamak, tabii ki, bu çapraz terimi tam olarak hiçbir şey yapmadan işlev. Ama bir dokunuş unsafeCoerce daha dürüst. Ve o vacuous 25 *...* eklendi

Ya da bir değerlendiricisi yazın. Burada b serbest değişken değerleri.

data Val b
  =  b :$$ [Val b]                              -- a stuck application
  |  forall a. LV (a -> Val b) (Tm (Maybe a))   -- we have an incomplete environment

Sadece kilitler gibi Lambda temsil ettim. Değerlendiricisi bir ortam b aşırı değerler a serbest değişkenleri eşleme tarafından parametrize edilir.

eval :: (a -> Val b) -> Tm a -> Val b
eval g (Var a)   = g a
eval g (f :$ s)  = eval g f $$ eval g s where
  (b :$$ vs)  $$ v  = b :$$ (vs    [v])         -- stuck application gets longer
  LV g t      $$ v  = eval (maybe v g) t        -- an applied lambda gets unstuck
eval g (Lam t)   = LV g t

Bunu tahmin. Herhangi bir hedef kapalı bir terim değerlendirmek için

eval absurd :: Tm Void -> Val b

Daha genel olarak, Void nadiren kullanılan kendi kendine, ama kullanışlı istediğinizde kullanılan bir tür parametresi bir yol gösterir, bir tür imkansızlık (örneğin, burada, kullanarak bir serbest değişken bir kapalı dönem). Genellikle bu tür parametrize üst düzey fonksiyonları bütün türü (örneğin, burada, fmap, >>=, eval)işlemleri için parametreleri üzerinde kaldırma işlemleri ile gel. Void genel amaçlı bir operasyon olarak absurd geçirir.

Başka bir örnek için, Either e v umarım v ama bu tür bir özel durum neden olabilir e veren hesaplamaları yakalamak için kullanarak düşünün. Bu yaklaşım, kötü davranış riski düzgün belge için kullanabilirsiniz. Gayet iyi bu ortamda hesaplamaları uslu için, e Void, daha sonra kullanmak için ayırın

either absurd id :: Either Void v -> v

güvenli bir şekilde çalıştırmak için

either absurd Right :: Either Void v -> Either e v

güvensiz bir dünyada güvenli bileşenleri gömmek için.

Oh, ve son bir eğlence, işleme bir "olamaz". İmleci bu kadar genel bir fermuar yapımı, her yerde gösterir.

class Differentiable f where
  type D f :: * -> *              -- an f with a hole
  plug :: (D f x, x) -> f x       -- plugging a child in the hole

newtype K a     x  = K a          -- no children, just a label
newtype I       x  = I x          -- one child
data (f : : g)  x  = L (f x)      -- choice
                   | R (g x)
data (f :*: g)  x  = f x :&: g x  -- pairing

instance Differentiable (K a) where
  type D (K a) = K Void           -- no children, so no way to make a hole
  plug (K v, x) = absurd v        -- can't reinvent the label, so deny the hole!

Tam olarak alakalı olmasa da gerisini silmeye karar verdim.

instance Differentiable I where
  type D I = K ()
  plug (K (), x) = I x

instance (Differentiable f, Differentiable g) => Differentiable (f : : g) where
  type D (f : : g) = D f : : D g
  plug (L df, x) = L (plug (df, x))
  plug (R dg, x) = R (plug (dg, x))

instance (Differentiable f, Differentiable g) => Differentiable (f :*: g) where
  type D (f :*: g) = (D f :*: g) : : (f :*: D g)
  plug (L (df :&: g), x) = plug (df, x) :&: g
  plug (R (f :&: dg), x) = f :&: plug (dg, x)

Aslında, belki de ilgili. Eğer maceracı hissediyorsanız, unfinished article Void ücretsiz değişkenler açısından temsili sıkıştırmak için nasıl kullanılacağını gösterir

data Term f x = Var x | Con (f (Term f x))   -- the Free monad, yet again

herhangi bir sözdizimi Differentiable ve Traversable bir functor serbestçe oluşturulan f. Term f Void serbest değişkenleri ile bölgeleri göstermek için kullanıyoruz, ve 53* *göstermek içintüpleriiki veya daha fazla boş değişkenler yolların bir kavşak için ayrı, özgür bir değişken ya da serbest değişken bölgeler tünel aracılığıyla. Bu makalede, bir ara bitirmek gerekir.

Hayır değerleri ile bir tür (ya da en azından, kibar şirket sözünü etmeye değer yoktur), Void son derece yararlıdır. Ve absurd bunu kullanmak nasıl.