최근에는 NegativeLiterals확장 프로그램이 사용 되는지 감지 할 수있는 Haskell 프로그램을 작성하는 것을 좋아했습니다 . 나는 다음을 생각해 냈다.

data B=B{u::Integer}
instance Num B where{fromInteger=B;negate _=B 1}
main=print$1==u(-1)

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

True정상적으로 인쇄 됩니다 False.

이제 나는이 일을하는 것이 너무나 즐거웠습니다. 어떤 다른 하스켈 언어 확장 프로그램을 사용할 수 있습니까?

규칙

당신이하고 언어 확장 (경고 괜찮) 출력 두 가지 않고 모두 컴파일 하스켈 프로그램을 작성해야합니다 특정 언어 확장 균열 이 아닌 오류 추가하여 (언어 확장으로 실행하고 해제 할 때 값을 No접두사에 언어 확장). 이런 식으로 위 코드를 다음과 같이 단축 할 수 있습니다.

data B=B{u::Integer}
instance Num B where{fromInteger=B;negate _=B 1}
main=print$u(-1)

이는 인쇄 1및 -1.

확장을 크랙하기 위해 사용하는 모든 방법은 해당 확장에 고유해야합니다. 사용 가능한 컴파일러 플래그 또는 LanguageExtensions를 임의로 감지하는 방법이있을 수 있습니다. 추가 언어 확장을 활성화하거나 -O바이트 수를 무료로 사용하여 컴파일러 최적화를 변경할 수 있습니다.

언어 확장

당신은하지 않는 언어 확장 깰 수없는 No상대를 (예를 들어 Haskell98, Haskell2010, Unsafe, Trustworthy, Safe) 다음은 위에서 설명한 조건에 해당하지 않기 때문입니다. 다른 모든 언어 확장은 공정한 게임입니다.

채점

가장 먼저 크래킹 한 언어 확장에 대해 1 점, 가장 짧은 (바이트 단위로 측정) 크랙이있는 모든 언어 확장에 대해 1 점이 추가로 제공됩니다. 두 번째 요점은 이전 제출에 찬성하여 유대가 깨질 것입니다. 높은 점수가 좋습니다

당신은에 처음으로 제출 한 점을 득점 할 수 없습니다 NegativeLiterals또는 QuasiQuotes이미 그들을 금이 게시물의 몸에서 그들을 포함되어 있기 때문에. 그러나 각각의 가장 짧은 균열에 대한 점수를 얻을 수 있습니다. 여기 내 균열이 있습니다QuasiQuotes

import Text.Heredoc
main=print[here|here<-""] -- |]

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

MagicHash, 30 바이트

x=1
y#a=2
x#a=1
main=print$x#x

-XMagicHash 출력 1, -XNoMagicHash 출력 2

MagicHash는 변수 이름이로 끝나도록 #합니다. 따라서, 확장자,이 두 가지 기능을 정의 y#하고 x#있는 각각의 값을 일정한를 반환 2하거나 1. x#x1을 반환한다 (이 때문에 x#인가 1)

확장이 없으면 #두 개의 인수를 사용하여를 반환하는 하나의 함수 를 정의 합니다 2. 는 x#a=1도달하지 도착 결코 패턴이다. 그런 다음 x#x은 1#12를 반환합니다.

CPP, 33 20 바이트

main=print$0-- \
 +1

인쇄 0와 -XCPP와 1와 -XNoCPP.

을 사용하면 줄 바꿈 앞 -XCPP의 슬래시 \가 줄 바꿈을 제거하므로 코드는 주석의 일부로 main=print$0-- +1만 0인쇄되고 인쇄됩니다 +1.

플래그가 없으면 주석이 무시되고 두 번째 행은 들여 쓰기 때문에 이전 행의 일부로 구문 분석됩니다.

이전 접근 방식 #define

x=1{-
#define x 0
-}
main=print x

또한 인쇄 0와 -XCPP와 1함께 -XNoCPP.

NumDecimals, 14 바이트

main=print 1e1

-XNumDecimals가 인쇄합니다 10. -XNoNumDecimals가 인쇄합니다 10.0.

이진 리터럴, 57 바이트

b1=1
instance Show(a->b)where;show _=""
main=print$(+)0b1

-XBinaryLiterals 는 단일 줄 바꿈을 인쇄합니다. -XNoBinaryLiterals 는 a를 인쇄합니다 1.

더 좋은 방법이 있다고 확신합니다. 하나를 찾으면 게시하십시오.

MonomorphismRestriction + 7 기타, 107 바이트

이것은 -XTemplateHaskell항상 플래그를 요구하는 TH를 사용합니다 .

파일 T.hs, 81 + 4 바이트

module T where
import Language.Haskell.TH
p=(+)
t=reify(mkName"p")>>=stringE.show

메인, 22 바이트

import T
main=print $t

플래그로 컴파일 MonomorphismRestriction하는 유형 강제 p로를 Integer -> Integer -> Integer따라서 다음과 같은 출력을 생성합니다 :

"VarI T.p (AppT (AppT ArrowT (ConT GHC.Integer.Type.Integer)) (AppT (AppT ArrowT (ConT GHC.Integer.Type.Integer)) (ConT GHC.Integer.Type.Integer))) Nothing"

NoMonomorphismRestriction 플래그로 컴파일 p하면 가장 일반적인 유형 , 즉 Num a => a->a->a-다음과 같이 생성하십시오 ( VarT이름을으로 단축 a).

"VarI T.p (ForallT [KindedTV a StarT] [AppT (ConT GHC.Num.Num) (VarT a)] (AppT (AppT ArrowT (VarT a)) (AppT (AppT ArrowT (VarT a)) (VarT a)))) Nothing"

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

대안

위의 코드는의 유형을 단순히 출력하기 때문에 pHaskell이 유형을 유추하는 방법에 영향을주는 모든 플래그를 사용하여 수행 할 수 있습니다. 플래그를 지정하고 함수를 대체 할 내용 p과 필요한 경우 추가 플래그 ( -XTemplateHaskell)를 지정합니다.

오버로드 된 목록, 106 바이트

추가로 필요한 사항 -XNoMonomorphismRestriction:

p=[]

어느 p :: [a]하거나 p :: IsList l => l, 온라인으로보십시오!

오버로드 된 문자열, 106 바이트

추가로 필요한 사항 -XNoMonomorphismRestriction:

p=""

어느 p :: String하거나 p :: IsString s => s, 온라인으로보십시오!

PolyKinds, 112 바이트

이것은 전적으로 @CsongorKiss 때문입니다.

data P a=P 

어느 P :: P a하거나 P :: forall k (a :: k). P a, 온라인으로보십시오!

MonadComprehensions, 114 바이트

p x=[i|i<-x]

어느 p :: [a] -> [a]하거나 p :: Monad m => m a -> m a, 온라인으로보십시오!

명명 된 와일드 카드, 114 바이트

이것은 @Laikoni에 의해 발견되었으며, 추가로 필요합니다 -XPartialTypeSignatures:

p=id::_a->_a

둘 다 저장 유형 ( p :: a -> a)을 가지고 있지만 GHC는 변수에 대해 다른 이름을 생성 하고 온라인으로 시도하십시오!

ApplicativeDo, 120 바이트

p x=do i<-x;pure i

어느 p :: Monad m => m a -> m a하거나 p :: Functor f => f a -> f a, 온라인으로보십시오!

오버로드 된 레이블, 120 바이트

추가 플래그가 필요합니다 -XFlexibleContexts.

p x=(#id)x
(#)=seq

어느와 같은 유형 p :: a -> b -> b또는 p :: IsLabel "id" (a->b) => a -> b, 온라인으로보십시오!

CPP, 27 25

main=print({-/*-}1{-*/-})

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

인쇄 ()에 대한 -XCPP및 1대한-XNoCPP

이전 버전:

main=print[1{-/*-},2{-*/-}]

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

인쇄 [1]와 -XCPP와 [1,2]그렇지.

크레딧 : 이것은 Laikoni의 답변에서 영감을 얻었지만 대신 #defineC 주석을 사용합니다.

ScopedTypeVariables, 162 113 바이트

instance Show[()]where show _=""
p::forall a.(Show a,Show[a])=>a->IO()
p a=(print::Show a=>[a]->IO())[a]
main=p()

-XScopedTypeVariables 인쇄 ""(빈), -XNoScopedTypeVariables 인쇄 "[()]".

편집 : 의견의 유용한 제안 덕분에 업데이트 된 솔루션

MonoLocalBinds, GADT 또는 TypeFamilies, 36 32 바이트

편집하다:

• -4 바이트 : 이것의 버전은 stasoid에 의해 위대한 polyglot chain 에 통합되었습니다 . 분명히이 제한을 트리거하는 데 실제 로컬 바인딩이 필요하지 않습니다 .

a=0
f b=b^a
main=print(f pi,f 0)

• 로 연장되지 ,이 프로그램은 인쇄 (1.0,1).

• 플래그 -XMonoLocalBinds , -XGADTs 또는 -XTypeFamilies 중 하나를 사용하여 인쇄합니다 (1.0,1.0).

• MonoLocalBinds확장 GADTs 및 유형의 가족에 의해 트리거 일부 직관적 타입 추론을 방지하기 위해 존재한다. 따라서이 확장은 두 확장에 의해 자동으로 켜집니다.

• 이다 다시 명시 적으로 그것을 해제 할 수 -XNoMonoLocalBinds이 트릭은 당신이하지 않는 가정합니다.

• 보다 잘 알려진 사촌 단일성 제한과 마찬가지로 MonoLocalBinds일부 값 ( 또는 같은 로컬 바인딩 에서 이름letwhere 이 최상위 수준에서도 발생할 수 있음)이 다형성이 되는 것을 방지하여 작동합니다 . 더 성가신 유형 유추를 위해 생성되었지만, 트리거 시점에 대한 규칙 은 가능하면 MR보다 훨씬 더 털이 있습니다.

• 확장자없이, 위의 프로그램 추론한다 종류 f :: Num a => a -> a수는, f piA를 기본값으로 Double하고 f 0에 Integer.

• 확장으로하게 추론 유형 f :: Double -> Double, 그리고 f 0이은을 반환 할 Double뿐만 아니라.
• 별도의 변수는 a=0: 기술적 인 규칙을 실행하는 데 필요한 a단사 사상 제한에 의해 명중되고, aA는 자유 변수 의 f것을 수단 f의 결합 그룹이되지 않는 완전히 일반화 된 수단 f되지 폐쇄 다형성이되지 않습니다 따라서 및.

오버로드 된 문자열, 65 48 32 바이트

RebindableSyntax를 활용하여 자체 버전의 fromString을 사용하여 문자열 리터럴을로 바꿉니다 "y".

main=print""
fromString _=['y']

로 컴파일해야합니다 -XRebindableSyntax -XImplicitPrelude.

-XOverloadedStrings인쇄 하지 않고 ""; 인쇄합니다 "y".

또한 동일한 기술이 (예 : OverloadedLists)와 함께 작동한다는 사실을 알게되었습니다.

오버로드 된 목록, 27 바이트

main=print[0]
fromListN=(:)

로 컴파일해야합니다 -XRebindableSyntax -XImplicitPrelude.

-XOverloadedLists인쇄 하지 않고 [0]; 인쇄합니다 [1,0].

BangPatterns, 32 바이트

(!)=seq
main|let f!_=0=print$9!1

-XBangPatterns 는 인쇄 1하지만 -XNoBangPatterns 는 인쇄 0합니다.

BangPatterns 플래그를 사용하면 WHNF !에 강제로 평가를 사용하여 패턴에 주석을 달 수 있으며,이 경우 9!1최상위 정의를 사용합니다 (!)=seq. 플래그를 사용하지 않으면 f!_새 연산자를 정의하고 (!)최상위 정의를 숨 깁니다.

ApplicativeDo, 104 바이트

import Control.Applicative
z=ZipList
instance Monad ZipList where _>>=_=z[]
main=print$do a<-z[1];pure a

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

을 사용 ApplicativeDo하면 인쇄

ZipList {getZipList = [1]}

그것없이, 그것은 인쇄

ZipList {getZipList = []}

ZipList에 대한 인스턴스는 Applicative있지만 기본 라이브러리에는없는 몇 가지 유형 중 하나입니다 Monad. 어딘가에 숨어있는 더 짧은 대안이있을 수 있습니다.

엄격, 87 84 82 바이트

^{dfeuer 덕분에 -5 바이트 !}

BlockArguments주변의 파 렌스 를 저장하면 적을 수 있습니다 \_->print 1.

import Control.Exception
0!_=0
main=catch @ErrorCall(print$0!error"")(\_->print 1)

-XStrict로 이것을 실행하면 a를 인쇄하고 -XNoStrict로1 그것을 실행하면 a 를 인쇄합니다 0. 이것은 Haskell이 기본적으로 게으르고 error""결과가 0의 첫 번째 인수와 일치 할 때 결과가 될 것이라는 것을 이미 알고 있기 때문에 평가할 필요가 없다는 것을 사용합니다. (!)이 동작은 해당 플래그로 변경하여 런타임이 두 인수를 모두 평가하도록합니다.

어떤 경우에도 아무것도 인쇄 할 수 없다면 메인을 대체하여 75 바이트 로 줄일 수 있습니다 ( dfeuer에 의해 일부 바이트가 꺼짐 ).

main=catch @ErrorCall(print$0!error"")mempty

엄격한 데이터, 106 99 93 바이트

^{dfeuer 덕분에 -15 바이트 !}

이것은 기본적으로 동일하지만 대신 데이터 필드와 함께 작동합니다.

import Control.Exception
data D=D()
main=catch @ErrorCall(p$seq(D$error"")0)(\_->p 1);p=print

인쇄 1와 -XStrictData 플래그 0와 -XNoStrictData .

어떤 경우에도 인쇄가 허용되지 않으면 메인을 ( dfeuer으로 19 바이트 오프) 대체하여 86 바이트 로 줄일 수 있습니다.

main=catch @ErrorCall(print$seq(D$error"")0)mempty

참고 : 모든 솔루션에는 TypeApplications설정이 필요 합니다.

ApplicativeDo, 146 바이트

newtype C a=C{u::Int}
instance Functor C where fmap _ _=C 1
instance Applicative C
instance Monad C where _>>=_=C 0
main=print$u$do{_<-C 0;pure 1}

ApplicativeDo가 활성화되면 1을, 그렇지 않으면 0을 인쇄합니다

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

이진 리터럴, 31 24 바이트

편집하다:

• -7 바이트 : H.PWiz는 단일 b12변수 를 사용하여 추가 조정을 제안했습니다 .

함수 인스턴스를 피하면서 H.PWiz의 방법에 대한 조정 .

b12=1
main=print$(+)0b12

• 함께 -XNoBinaryLiterals , 0b12같은 lexes 0 b120 + 1 = 인쇄, 1.
• 함께 -XBinaryLiterals , 0b12같은 lexes 0b1 21 + 2 = 인쇄, 3.

ExtendedDefaultRules, 54 53 바이트

instance Num()
main=print(toEnum 0::Num a=>Enum a=>a)

인쇄 ()와 -XExtendedDefaultRules와 0와 -XNoExtendedDefaultRules.

이 플래그는 기본적으로 GHCi에서 활성화되어 있지만 GHC에서는 활성화되어 있지 않습니다. 최근 BMO 가 신속하게 도움을 줄 수 있었지만 혼란 스러웠습니다 .

위의 코드는 GHCi의 유형 기본값 이 설명 된 GHC 사용 설명서의 예제 를 골프화 한 것 입니다.

Ørjan Johansen 덕분에 -1 바이트 !

RebindableSyntax , 25 바이트

나는 최근에 게시 된 것을 기억하지 못하는 쉬운 것을 발견했을 때 최근에 게시 된 GHC의 Extensions Guide를 읽고있었습니다 .

main|negate<-id=print$ -1

• -XNoRebindableSyntax를 사용 하여 인쇄합니다 -1.
• -XRebindableSyntax를 사용 하여 인쇄합니다 1.

또한 필요 -XImplicitPrelude, 또는 다른 import Prelude코드 자체입니다.

• -XRebindableSyntax Haskell의 일부 구문 설탕의 동작을 변경하여 재정의 할 수 있도록합니다.
• -1에 대한 구문 설탕입니다 negate 1.
• 일반적으로 이것은 negate이다 Prelude.negate,하지만 확장자는 "중의 negate로 정의, 사용 시점에 범위에" id.
• 확장은 Prelude모듈 을 대체하는 데 사용되기 때문에 일반적인 암시 적 가져 오기를 자동으로 비활성화하지만 여기에 다른 Prelude기능 (예 print:)이 필요하므로로 다시 활성화됩니다 -XImplicitPrelude.

엄격한 52 바이트

import GHC.IO
f _=print()
main=f$unsafePerformIO$f()

-XStrict

-XNoStrict

을 사용 하면 추가 시간을 -XStrict인쇄 ()합니다.

2 바이트 동안 @Sriotchilism O'Zaic에게 감사드립니다.

엄격한 데이터, 58 바이트

import GHC.Exts
data D=D Int
main=print$unsafeCoerce#D 3+0

(링크는 약간 구식입니다. 수정됩니다.)

-XNoStrictData

-XStrictData

필요 MagicHash(우리가 가져올 수 있도록하는 GHC.Exts대신 Unsafe.Coerce) 및 -O(절대적으로 필요한 작은 엄격한 필드의 포장을 풀 수 있도록).

을 사용 -XStrictData하여 3을 인쇄합니다. 그렇지 않으면 (아마도 태그가 붙은) 포인터의 정수 값을 사전 할당 된의 사본에 인쇄 3::Integer합니다 (3 일 수 없음).

설명

유형 기본값을 기반으로 약간의 확장으로 이해하기가 조금 더 쉽습니다. 서명을 사용하면 추가를 삭제할 수 있습니다.

main=print
  (unsafeCoerce# D (3::Integer)
    :: Integer)

마찬가지로

main=print
  (unsafeCoerce# $
    D (unsafeCoerce# (3::Integer))
    :: Integer)

왜 3을 인쇄합니까? 이것은 놀라운 것 같습니다! 글쎄, 작은 Integer값은 Ints 와 매우 유사하게 표현 되며, 엄격한 데이터를 사용하면 Ds 와 같이 표현 됩니다. 정수가 작거나 큰 양 / 음인지 여부를 나타내는 태그를 무시합니다.

확장명없이 3을 인쇄 할 수없는 이유는 무엇입니까? 메모리 레이아웃 이유를 제외하고 낮은 비트 (32 비트의 경우 2 가장 낮음, 64 비트의 경우 3 가장 낮음)가 3 인 데이터 포인터는 세 번째 생성자에서 작성된 값을 나타내야합니다. 이 경우 음의 정수 가 필요합니다 .

UnboxedTuples, 52 바이트

import Language.Haskell.TH
main=runQ[|(##)|]>>=print

필요합니다 -XTemplateHaskell. 인쇄 ConE GHC.Prim.(##)와 -XUnboxedTuples 와 UnboundVarE ##와 -XNoUnboxedTuples .

오버로드 된 목록, 76 바이트

import GHC.Exts
instance IsList[()]where fromList=(():)
main=print([]::[()])

로 -XOverloadedLists 은 인쇄 [()]. 로 -XNoOverloadedLists 그것은 인쇄[]

추가 플래그가 필요합니다 : -XFlexibleInstances,-XIncoherentInstances

HexFloatLiterals , 49 25 바이트

Ørjan Johansen 덕분에 -24 바이트

main|(.)<-seq=print$0x0.0

인쇄 0.0와 -XHexFloatLiterals와 0와 -XNoHexFloatLiterals.

HexFloatLiterals가 ghc 8.4.1에 추가되었으므로 TIO 링크가 없지만 TIO에는 ghc 8.2.2가 있습니다.

ScopedTypeVariables, 37 바이트

main=print(1::_=>a):: ∀a.a~Float=>_

이것은 또한 필요 UnicodeSyntax, PartialTypeSignatures, GADTs,와 ExplicitForAll.

온라인으로 사용해보십시오 (확장자없이)

온라인으로 사용해보십시오 (확장자 포함)

설명

부분 형식 서명은 바이트를 저장하기위한 것입니다. 다음과 같이 채울 수 있습니다.

main=print(1::(Num a, Show a)=>a):: ∀a.a~Float=>IO ()

범위 형 변수의 a유형의 1구속은이어야 a의 형태 main자체로 제한된다 Float. 범위가 지정된 유형 변수가 없으면 1기본값은 type Integer입니다. 이후 Float및 Integer값이 다르게 표시됩니다, 우리는 그들을 구별 할 수 있습니다.

무려 19 바이트 인 @ ØrjanJohansen에게 감사합니다! 그는 Show산술의 차이보다 다른 숫자 유형의 인스턴스 간의 차이를 이용하는 것이 훨씬 낫다는 것을 깨달았습니다 . 그는 main제약이 실제로 그것을 명확하게하기 때문에 "구문 적으로 모호한" 유형을 그대로 두는 것이 좋다는 것을 깨달았다 . 로컬 기능을 제거 main하면 5 바이트를 절약하기 위해 유형 서명을 제거 (RHS로 이동) 할 수있었습니다.

DeriveAnyClass, 121 113 바이트

^{꽤 많은 바이트에 대한 dfeuer 에 감사드립니다 !}

import Control.Exception
newtype M=M Int deriving(Show,Num)
main=handle h$print(0::M);h(_::SomeException)=print 1

-XDeriveAnyClass 는 인쇄 1하지만 -XNoDeriveAnyClass 는 인쇄합니다 M 0.

이것은 경고에서 알 수 있듯이 DeriveAnyClass와 GeneralizedNewtypeDeriving이 모두 사용 가능한 경우 DeriveAnyClass가 기본 전략이라는 사실을 이용합니다. 이 플래그는 행복하게 모든 방법 빈 구현을 생성하지만 GeneralizedNewtypeDeriving 실제로 기본 유형의 구현을 사용하는 스마트 충분하고 있기 때문에 Int하는 Num것이이 경우 실패하지 않습니다.

플래그를 사용하도록 설정 한 경우 아무것도 인쇄하지 않으면 main다음으로 대체하여 109 바이트가됩니다 .

main=print(0::M)`catch`(mempty::SomeException->_)

PostfixOperators, 63 바이트

import Text.Show.Functions
instance Num(a->b)
main=print(0`id`)

온라인으로 사용해보십시오 (확장자없이)

온라인으로 사용해보십시오 (확장자 포함)

이것은 내가 쓴 Hugs / GHC 폴리 글롯 의 컷 다운 버전입니다 . 설명은 해당 게시물을 참조하십시오. @ ØrjanJohansen에게 id4 바이트를 절약하면서 커스텀 연산자 대신 사용할 수 있다는 사실을 알게 된 덕분 입니다.

DeriveAnyClass, 104 바이트

import Control.Exception
newtype M a=M a deriving(Show,Exception)
main=print.displayException$M Deadlock

온라인으로 사용해보십시오 (확장자없이)

온라인으로 사용해보십시오 (확장자 포함)

또한 필요합니다 GeneralizedNewtypeDeriving.

엄격한 데이터, 97 바이트

import GHC.Generics
data A=A()deriving Generic
main=print$selDecidedStrictness$unM1.unM1$from$A()

온라인으로 사용해보십시오 (엄격한 데이터 없음)

온라인으로 사용해보십시오 (엄격한 데이터)

또한 필요합니다 DeriveGeneric.

UnicodeSyntax, 33 바이트

(∀)=0
main|forall<-1=print(∀)

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

템플릿 Haskell, 140 91 바이트

작은 수정으로 mauke 에서 복사했습니다 . 무슨 일인지 모르겠어요

Ørjan Johansen 덕분에 -49 바이트

import Language.Haskell.TH
instance Show(Q a)where show _=""
main=print$(pure$TupE[]::ExpQ)

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

MonomorphismRestriction, 31 29 바이트

편집하다:

• H.PWiz에 의해 개선 된 -2 바이트

f=(2^)
main=print$f$f(6::Int)

-XMonomorphismRestriction이 인쇄 0됩니다. -XNoMonomorphismRestriction이 인쇄 18446744073709551616됩니다.

• 제한 사항으로, 두 가지 용도 f는 동일한 유형이어야하므로 프로그램 2^2^6 = 2^64은 64 Int비트 플랫폼 (64 비트 플랫폼)으로 인쇄되어 오버 플로우됩니다 0.
• 제한없이 프로그램 2^64은 bignum으로 인쇄합니다 Integer.

ScopedTypeVariables, 119 97 바이트

작은 수정으로 mauke 에서 복사했습니다 .

현재 ScopedTypeVariables에 대한 두 가지 다른 답변이 있습니다 : Csongor Kiss의 113 바이트 및 dfeuer의 37 바이트 . 이 제출은 다른 Haskell 확장이 필요하지 않다는 점에서 다릅니다.

Ørjan Johansen 덕분에 -22 바이트

class(Show a,Num a)=>S a where s::a->IO();s _=print$(id::a->a)0
instance S Float
main=s(0::Float)

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