약간의 알려진 사실은 충분한 언어 확장 (ghc)을 켜면 Haskell이 동적으로 형식화 된 해석 언어가된다는 것입니다! 예를 들어 다음 프로그램은 추가를 구현합니다.

{-# 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)

이것은 더 이상 Haskell처럼 보이지 않습니다. 객체를 조작하는 대신 유형을 조작합니다. 각 번호는 고유 한 유형입니다. 함수 대신에 타입 클래스가 있습니다. 기능적 종속성은 유형 간 함수로 사용할 수 있습니다.

그렇다면 코드를 어떻게 호출합니까? 우리는 다른 수업을 사용합니다

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

이것은 타입을 test타입 4 + 3으로 설정합니다. 만약 이것을 ghci로 열면 test실제로 타입 7이라는 것을 알 수 있습니다 .

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

직무

두 Peano 숫자 (음이 아닌 정수)를 곱하는 클래스를 구현하고 싶습니다. Peano 숫자는 위의 예에서 동일한 데이터 유형을 사용하여 구성됩니다.

data Zero
data Succ a

그리고 당신의 수업은 위와 같은 방식으로 평가 될 것입니다. 원하는대로 수업 이름을 지정할 수 있습니다.

바이트 단위로 무료로 원하는 ghc 언어 확장을 사용할 수 있습니다.

테스트 사례

이 테스트 사례는 클래스의 이름이 M이고 원하는 경우 다른 이름을 지정할 수 있습니다.

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

결과

*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)))))))))))))))))

기술 인터뷰 입력에서 영감을 얻습니다

130 121 바이트

^{Ørjan Johansen 덕분에 -9 바이트}

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

온라인으로 사용해보십시오!

이것은 덧셈 (+)과 곱셈을 위한 닫힌 타입 패밀리를 정의합니다 (*). 그런 다음 유형 패밀리를 동등 구속 조건과 함께 (#)사용하여 (*)패밀리 유형의 세계에서 유형 클래스 프롤로그의 세계로 변환합니다.

139 바이트

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

온라인으로 사용해보십시오!

타입 연산자를 정의합니다 *. 프롤로그 프로그램과 동일합니다.

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와 Hat Wizard는 각각 9 바이트를 절약했습니다. 감사!

패밀리 버전, 115 바이트

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

온라인으로 사용해보십시오!

이것은 potato44 's 와 같은 폐쇄 형 패밀리를 사용합니다 . 다른 답변과 달리 나는 1 가지 유형의 가족 만 사용합니다.

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

이것은 세 가지 유형의 연산자를 정의합니다. 본질적으로 구현 (a*b)+c합니다. 우리는 오른손 인수를 총계에 추가하고 싶을 때마다 대신 누적기에 넣습니다.

이것은 우리가 (+)전혀 정의 할 필요가 없도록 합니다. 기술적으로이 제품군을 사용하여 추가를 구현할 수 있습니다.

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

클래스 버전, 137 바이트

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

온라인으로 사용해보십시오!

이 클래스 버전은 패밀리 버전과 약간 차이가 있지만 여기서는 가장 짧은 클래스 버전보다 짧습니다. 그것은 내 가족 버전과 같은 접근법을 사용합니다.