Core 언어 둘러 보기 (작성 중)

a ~ b

{-# LANGUAGE NoImplicitPrelude #-} 
-- 하스켈의 표준 라이브러리라 할 수 있는 Prelude를 쓰려면 명시하겠다는 뜻입니다.

class Ord a where
  compare :: a -> a -> Bool

instance Ord Int where
  compare x y = x <= y

foo :: Int -> Int -> Bool
foo = compare

λ> :t foo
foo :: GHC.Types.Int -> GHC.Types.Int -> GHC.Types.Bool
λ> foo 1 1

==================== Simplified expression ====================
let {
  it_a1wP :: GHC.Types.Bool -- 결과 저장을 위한 변수
  [LclId, -- it_a1wP의 속성을 [...] 안에 써줍니다. LclId는 지역 변수란 뜻
   Unf=Unf{Src=<vanilla>, TopLvl=False, -- 최적화 관련 속성. 
           Value=False, ConLike=False, WorkFree=False, Expandable=False,
           Guidance=IF_ARGS [] 50 0}]
  it_a1wP = Ghci5.foo (GHC.Types.I# 1#) (GHC.Types.I# 1#) } in
GHC.Base.thenIO -- IO a -> IO b -> IO b 첫 번째 IO작업이 끌나고, 다음 IO작업 실행을 의미
  @() -- 타입을 명시하지 않거나, 타입을 무시하는 의미
  @[GHC.Types.Any] -- 리스트 타입 Any
  (System.IO.print @GHC.Types.Bool GHC.Show.$fShowBool it_a1wP)
  (GHC.Base.returnIO
     @[GHC.Types.Any]
     (GHC.Types.: -- 리스트의 Con을 뜻하는 (:))
        @GHC.Types.Any
        (case Unsafe.Coerce.unsafeEqualityProof
                @(*) @GHC.Types.Any @GHC.Types.Bool
         of
         { Unsafe.Coerce.UnsafeRefl v2_aoH ->
         it_a1wP `cast` (Sub v2_aoH :: GHC.Types.Bool ~R# GHC.Types.Any)
         })
        (GHC.Types.[] @GHC.Types.Any)))


True

λ> 42
42
λ> it + 1
43

let {
  it_a1wP :: Bool
  [LclId,... 최적화]
  it_a1wP = foo (I# 1#) (I# 1#) } in 
  -- 위 구문은 여기서 끝나고, 아래는 GHCi에서 출력에 관한 동작입니다.
thenIO -- <--- 함수 
  @() 
  @[Any] 
  (System.IO.print @Bool $fShowBool it_a1wP) -- <--- 함수
  (returnIO -- <--- 함수
     @[Any]
     (: 
        @Any
        (case Unsafe.Coerce.unsafeEqualityProof
                @(*) @Any @Bool
         of
         { Unsafe.Coerce.UnsafeRefl v2_aoH ->
         it_a1wP `cast` (Sub v2_aoH :: Bool ~R# Any)
         })
        ([] @Any)))

λ> arr (const 42) ()
42

λ> :t arr (const 42)
arr (const 42) :: (Arrow a, GHC.Num.Num c) => a b c

λ> :t arr (const 42) ()
arr (const 42) () :: GHC.Num.Num t => t

==================== Simplified expression ====================
let {
  it_aFo :: forall {t}. GHC.Num.Num t => t 
  [LclId, 
   Arity=1, --하나의 인자, Num t => 딕셔너리를 받는다.
   Unf : 
   Unf=Unf{Src=<vanilla>, TopLvl=False,
           Value=True, ConLike=True, WorkFree=True, Expandable=True,
           Guidance=IF_ARGS [30] 100 0}]
  it_aFo 
    = \ (@t_aWv) ($dNum_aWP :: GHC.Num.Num t_aWv) ->
        Control.Arrow.arr
          @(->) -- (->) 타입 적용
          Control.Arrow.$fArrowFUN -- `Arrow`클래스의 `Fun` 딕셔너리
          @()
          @t_aWv
          (GHC.Base.const
             @t_aWv
             @()
             (GHC.Num.fromInteger @t_aWv $dNum_aWP (GHC.Num.Integer.IS 42#)))
          GHC.Tuple.Prim.() } in
          ...

==================== Simplified expression ====================
GHC.Base.bindIO
  @()
  @[GHC.Types.Any]
  (GHC.GHCi.ghciStepIO
     @GHC.Types.IO
     GHC.GHCi.$fGHCiSandboxIOIO
     @()
     (GHC.Base.pure
        @GHC.Types.IO GHC.Base.$fApplicativeIO @() GHC.Tuple.Prim.()))
  (\ (it_aXZ :: ()) ->
     GHC.Base.returnIO
       @[GHC.Types.Any]
       (GHC.Types.:
          @GHC.Types.Any
          (case Unsafe.Coerce.unsafeEqualityProof @(*) @GHC.Types.Any @() of
           { Unsafe.Coerce.UnsafeRefl v2_aoH ->
           it_aXZ `cast` (Sub v2_aoH :: () ~R# GHC.Types.Any)
           })
          (GHC.Types.[] @GHC.Types.Any)))