最近、NegativeLiterals拡張機能が使用されているかどうかを検出できるHaskellプログラムを作成することができました。私は次のことを思いつきました：

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

オンラインでお試しください！

これはTrue正常に印刷され、Falseます。

今、私はこれをするのがとても楽しかったです。私はあなた全員に挑戦を広げています。他にどのHaskell言語拡張機能をクラックできますか？

ルール

特定の言語拡張をクラックするには、言語拡張ありとなしの両方でコンパイルし（警告は問題ありません）、言語拡張を使用して実行したときに2つの異なる非エラー値を出力するHaskellプログラムを作成する必要があります（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ポイント追加されます。2番目の点については、以前の提出を支持して関係が破られるでしょう。スコアが高いほど良い

最初の投稿でポイントを獲得することはできません。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では、変数名を#。したがって、拡張機能では、これは2つの関数y#を定義し、x#それぞれが値を取り、定数2またはを返し1ます。x#x1を返します（x#適用されるため1）

拡張なしで、#これは2つの引数を取り、を返す1つの関数を定義します2。x#a=1達しれることは決してありませんパターンです。次にx#xである1#12を返します。

CPP、33 20バイト

main=print$0-- \
 +1

およびで印刷0します。-XCPP1-XNoCPP

では-XCPP、\改行の前のスラッシュは改行を削除するため、コードはコメントの一部になり、印刷されるmain=print$0-- +1だけ0です+1。

フラグがない場合、コメントは無視され、2行目はインデントされているため前の行の一部として解析されます。

以前のアプローチ #define

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

およびで印刷0します。-XCPP1-XNoCPP

NumDecimals、14バイト

main=print 1e1

-XNumDecimalsを出力し10ます。-XNoNumDecimalsが出力され10.0ます。

BinaryLiterals、57バイト

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

-XBinaryLiteralsは、単一の改行を出力します。-XNoBinaryLiteralsは1。

これを行うためのより良い方法があると確信しています。見つかった場合は投稿してください。

単相性制限+ 7その他、107バイト

これは、フラグを必要とするTHを使用します -XTemplateHaskell、常にします。

ファイル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を使用してコンパイルすると、pto のタイプが強制され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）のみを指定します。

OverloadedLists、106バイト

さらに必要なもの-XNoMonomorphismRestriction：

p=[]

どちらかp :: [a]またはp :: IsList l => l、オンラインそれらを試してみてください！

OverloadedStrings、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、オンラインそれらを試してみてください！

NamedWildCards、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、オンラインそれらを試してみてください！

OverloadedLabels、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]それ以外の場合は。

クレジット：これは、ライコニの答えに触発されていますが、代わりに#define単にCコメントを使用しています。

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バイト：このバージョンは、すべての宣言を最上位に置くことに驚いたスタソイドによって、素晴らしいポリグロットチェーンに組み込まれました。明らかにこの制限をトリガーするには、実際のローカルバインディングは必要ありません。

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

• で拡張子のない、このプログラムが印刷さ(1.0,1)。

• フラグ-XMonoLocalBinds、-XGADTs、または-XTypeFamiliesのいずれかを使用すると、印刷され(1.0,1.0)ます。

• このMonoLocalBinds拡張機能は、GADTとタイプファミリによってトリガーされる直感的でないタイプ推論を防ぐために存在します。そのため、この拡張機能は他の2人によって自動的にオンになります。

• それは明示的に再びオフにする可能です-XNoMonoLocalBinds、このトリックは、あなたがいないと仮定し、。

• よく知られている単相性の制限の従兄弟のように、MonoLocalBindsいくつかの値（またはのようなローカルバインディングでは、名前がletwhere明らかにトップレベルでも発生する可能性があります）が多相性であることを防止します。saner型推論用に作成されているにもかかわらず、それがトリガーされるタイミングのルールが、は、可能であればMRよりもさらに毛深いです。

• 任意の拡張子がなければ、上記のプログラムは、型を推測f :: Num a => a -> aできるように、f piをデフォルトにDoubleしてf 0までInteger。

• 拡張により、推論される型はになりf :: Double -> Double、同様にf 0を返す必要がありDoubleます。
• 別の変数はa=0技術的なルールをトリガするために必要とされる：a単相性制限に見舞われており、aある自由変数のfことを意味し、fの結合グループがされていない完全に一般化された手段、fされていない閉じたため、多型になっていません。

OverloadedStrings、65 48 32バイト

RebindableSyntaxを利用して、独自のバージョンのfromStringを使用して、文字列リテラルをに変換し"y"ます。

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

でコンパイルする必要があり-XRebindableSyntax -XImplicitPreludeます。

-XOverloadedStringsプリントなし""; プリント付き"y"。

また、同じ手法が（たとえば）OverloadedListsで機能することは、私に今だけ印象的でした。

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は、ではなく、のインスタンスを持つベースライブラリの数少ないタイプの1つ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は怠zyであり、評価の必要はありません。これはerror""、結果が0の最初の引数で一致したときに結果が得られることを既に知っているためです。(!)。この動作はそのフラグで変更できます。

1つのケースで何も印刷できない場合、メインを（さらにdfeuerによっていくつかのバイトが）75バイトに置き換えることができます。

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

StrictData、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。

1つのケースで何も印刷できない場合は、メインを86バイトに置き換えて（dfeuerで 19バイト）減らすことができます。

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を印刷します

オンラインでお試しください！

BinaryLiterals、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)

およびで印刷()します。-XExtendedDefaultRules0-XNoExtendedDefaultRules

このフラグは、GHCiではデフォルトで有効になっていますが、GHCでは無効になっており、最近私にとって混乱を引き起こしましたが、BMOはすぐに助けてくれました。

上記のコードは、GHCiのデフォルトのタイプが説明されているGHCユーザーガイドの例のゴルフ版です。

ØrjanJohansenのおかげで-1バイト！

RebindableSyntax、25バイト

最近投稿したGHCの拡張機能ガイドを読んでいたとき、簡単なものに気づいたとき、まだここで見たことを思い出せませんでした。

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に感謝します。

StrictData、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ます。

説明

型のデフォルト設定に基づいて、少し拡張することで少し理解しやすくなります。署名を使用して、追加を削除できます。

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

同様に、

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

なぜ3を印刷するのですか？これは驚くべきことです！さて、小さなInteger値はIntsのように非常に表されます。D sのます。整数が小さいか大きい正/負かを示すタグを無視することになります。

拡張子なしで3を印刷できないのはなぜですか？メモリレイアウトの理由はさておき、低ビット（32ビットでは2、64ビットでは3）のデータポインターは、3番目のコンストラクターから構築された値を表す必要があります。この場合、負の整数が必要になります。

UnboxedTuples、52バイト

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

Requires -XTemplateHaskell. Prints ConE GHC.Prim.(##) with -XUnboxedTuples and UnboundVarE ## with -XNoUnboxedTuples.

OverloadedLists、76バイト

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

-XOverloadedListsそれが印刷さ[()]。-XNoOverloadedListsそれが印刷さ[]

This requires the additional flags: -XFlexibleInstances, -XIncoherentInstances

HexFloatLiterals, 49 25 bytes

-24 bytes thanks to Ørjan Johansen.

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

Prints 0.0 with -XHexFloatLiterals and 0 with -XNoHexFloatLiterals.

There are no TIO links because HexFloatLiterals was added in ghc 8.4.1, but TIO has ghc 8.2.2.

ScopedTypeVariables, 37 bytes

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

This also requires UnicodeSyntax,PartialTypeSignatures, GADTs, and ExplicitForAll.

Try it online (without extension)

Try it online (with extension)

Explanation

The partial type signatures are just to save bytes. We can fill them in like so:

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

With scoped type variables, the a in the type of 1 is constrained to be the a in the type of main, which itself is constrained to be Float. Without scoped type variables, 1 defaults to type Integer. Since Float and Integer values are shown differently, we can distinguish them.

Thanks to @ØrjanJohansen for a whopping 19 bytes! He realized that it was much better to take advantage of the difference between Show instances of different numerical types than differences in their arithmetic. He also realized that it was okay to leave the type of main "syntactically ambiguous" because the constraint actually disambiguates it. Getting rid of the local function also freed me up to remove the type signature for main (shifting it to the RHS) to save five more bytes.

DeriveAnyClass, 121 113 bytes

^{Thanks to dfeuer for quite some bytes!}

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

-XDeriveAnyClass prints 1 whereas -XNoDeriveAnyClass prints M 0.

This is exploiting the fact that DeriveAnyClass is the default strategy when both DeriveAnyClass and GeneralizedNewtypeDeriving are enabled, as you can see from the warnings. This flag will happily generate empty implementations for all methods but GeneralizedNewtypeDeriving is actually smart enough to use the underlying type's implementation and since Int is a Num it won't fail in this case.

If printing nothing in case the flag is enabled replacing the main by the following would be 109 bytes:

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

PostfixOperators, 63 bytes

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

Try it online (without extension)

Try it online (with extension)

This is a cut-down version of a Hugs/GHC polyglot I wrote. See that post for explanation. Thanks to @ØrjanJohansen for realizing I could use id instead of a custom operator, saving four bytes.

DeriveAnyClass, 104 bytes

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

Try it online (without extension)

Try it online (with extension)

Also requires GeneralizedNewtypeDeriving.

StrictData, 97 bytes

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

Try it online (no strict data)

Try it online (strict data)

Also requires DeriveGeneric.

UnicodeSyntax, 33 bytes

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

Try it online!

TemplateHaskell, 140 91 bytes

Just copied from mauke with small modifications. I don't know what's going on.

-49 bytes thanks to Ørjan Johansen.

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

Try it online!

MonomorphismRestriction, 31 29 bytes

Edit:

• -2 bytes with an improvement by H.PWiz

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

-XMonomorphismRestriction prints 0. -XNoMonomorphismRestriction prints 18446744073709551616.

• With the restriction, the two uses of f are forced to be the same type, so the program prints 2^2^6 = 2^64 as a 64-bit Int (on 64-bit platforms), which overflows to 0.
• Without the restriction, the program prints 2^64 as a bignum Integer.

ScopedTypeVariables, 119 97 bytes

Just copied from mauke with small modifications.

Currently there are two other answers for ScopedTypeVariables: 113 bytes by Csongor Kiss and 37 bytes by dfeuer. This submission is different in that it does not require other Haskell extensions.

-22 bytes thanks to Ørjan Johansen.

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

Try it online!