Bilinen bir gerçek şu ki, yeterli dil uzantılarını (ghc) açarsanız, Haskell dinamik olarak yazılmış bir yorumlanmış dil haline gelir! Örneğin, aşağıdaki program toplama işlemini uygular.

{-# Language MultiParamTypeClasses, FunctionalDependencies, FlexibleInstances, UndecidableInstances #-}

data Zero
data Succ a

class Add a b c | a b -> c
instance Add Zero a a
instance (Add a b c) => Add (Succ a) b (Succ c)

Bu artık Haskell'e benzemiyor. Birincisi, nesneler üzerinde çalışmak yerine türler üzerinde çalışıyoruz. Her sayı kendi tipidir. Fonksiyonlar yerine tip sınıflarımız var. İşlevsel bağımlılıklar, bunları türler arasında işlev olarak kullanmamızı sağlar.

Peki kodumuzu nasıl çağırıyoruz? Başka bir sınıf kullanıyoruz

class Test a | -> a
 where test :: a
instance (Add (Succ (Succ (Succ (Succ Zero)))) (Succ (Succ (Succ Zero))) a)
  => Test a

Bu test, tipini 4 + 3 tipine ayarlar . Bunu ghci'de açarsak, testbunun gerçekten tip 7 olduğunu göreceğiz :

Ok, one module loaded.
*Main> :t test
test :: Succ (Succ (Succ (Succ (Succ (Succ (Succ Zero))))))

Görev

İki Peano rakamını (negatif olmayan tamsayılar) çarpan bir sınıf uygulamanızı istiyorum. Peano rakamları yukarıdaki örnekte aynı veri türleri kullanılarak oluşturulacaktır:

data Zero
data Succ a

Ve sınıfınız da yukarıdaki gibi değerlendirilecektir. Sınıfınıza dilediğinizi adlandırabilirsiniz.

Baytlara ücretsiz olarak istediğiniz ghc dil uzantılarını kullanabilirsiniz.

Test Durumları

Bu test senaryoları sınıfınızın adlandırıldığını varsayar M, isterseniz başka bir ad verebilirsiniz.

class Test1 a| ->a where test1::a
instance (M (Succ (Succ (Succ (Succ Zero)))) (Succ (Succ (Succ Zero))) a)=>Test1 a

class Test2 a| ->a where test2::a
instance (M Zero (Succ (Succ Zero)) a)=>Test2 a

class Test3 a| ->a where test3::a
instance (M (Succ (Succ (Succ (Succ Zero)))) (Succ Zero) a)=>Test3 a

class Test4 a| ->a where test4::a
instance (M (Succ (Succ (Succ (Succ (Succ (Succ Zero)))))) (Succ (Succ (Succ Zero))) a)=>Test4 a

Sonuçlar

*Main> :t test1
test1
  :: Succ
       (Succ
          (Succ
             (Succ
                (Succ (Succ (Succ (Succ (Succ (Succ (Succ (Succ Zero)))))))))))
*Main> :t test2
test2 :: Zero
*Main> :t test3
test3 :: Succ (Succ (Succ (Succ Zero)))
*Main> :t test4
test4
  :: Succ
       (Succ
          (Succ
             (Succ
                (Succ
                   (Succ
                      (Succ
                         (Succ
                            (Succ
                               (Succ
                                  (Succ
                                     (Succ (Succ (Succ (Succ (Succ (Succ (Succ Zero)))))))))))))))))

Tipik teknik röportajdan ilham alır

130 121 bayt

^{Ørjan Johansen sayesinde -9 bayt}

type family a+b where s a+b=a+s b;z+b=b
type family a*b where s a*b=a*b+b;z*b=z
class(a#b)c|a b->c
instance a*b~c=>(a#b)c

Çevrimiçi deneyin!

Bu toplama (+)ve çarpma için kapalı tip aileleri tanımlar (*). Daha sonra tip ailesinin dünyasından daktilo sınıfı prolog dünyasına dönüştürmek için bir tip eşitliği ile birlikte tip ailesini (#)kullanan bir tip sınıfı tanımlanır (*).

139 bayt

class(a+b)c|a b->c;instance(Zero+a)a;instance(a+b)c=>(s a+b)(s c)
class(a*b)c|a b->c;instance(Zero*a)Zero;instance((a*b)c,(b+c)d)=>(s a*b)d

Çevrimiçi deneyin!

Bir tür işleci tanımlar *. Prolog programına eşdeğerdir:

plus(0, A, A).
plus(s(A), B, s(C)) :- plus(A, B, C).
mult(0, _, 0).
mult(s(A), B, D) :- mult(A, B, C), plus(B, C, D).

Potato44 ve Hat Wizard 9 bayt kurtardı. Teşekkürler!

Aile Sürümü, 115 bayt

type family(a%b)c where(a%b)(s c)=s((a%b)c);(s a%b)z=(a%b)b;(z%b)z=z
class(a#b)c|a b->c
instance(a%b)Zero~c=>(a#b)c

Çevrimiçi deneyin!

Bu, potato44 gibi kapalı tip bir aile kullanır . Diğer cevabın aksine sadece 1 tip aile kullanıyorum.

type family(a%b)c where
  -- If the accumulator is Succ c:
  -- the answer is Succ of the answer if the accumulator were c
  (a%b)(s c)=s((a%b)c)
  -- If the left hand argument is Succ a, and the right hand is b
  -- the result is the result if the left were a and the accumulator were b
  (s a%b)z=(a%b)b
  -- If the left hand argument is zero
  -- the result is zero
  (z%b)z=z

Bu, üç tipte bir operatörü tanımlar. Aslında uygular (a*b)+c. Sağ el argümanımızı toplama eklemek istediğimizde, bunu akümülatöre koyduk.

Bu, hiç tanımlamamıza engel olur (+). Teknik olarak, bu aileyi,

class Add a b c | a b -> c
instance (Succ Zero % a) b ~ c => Add a b c

Sınıf Sürümü, 137 bayt

class(a#b)c d|a b c->d
instance(a#b)c d=>(a#b)(f c)(f d)
instance(a#b)b d=>(f a#b)Zero d
instance(Zero#a)Zero Zero
type(a*b)c=(a#b)Zero c

Çevrimiçi deneyin!

Bu sınıf sürümü, aile sürümüne biraz önem verir, ancak yine de buradaki en kısa sınıf sürümünden daha kısadır. Benim aile versiyonumla aynı yaklaşımı kullanıyor.