Di recente ho avuto il piacere di scrivere un programma Haskell in grado di rilevare se l' NegativeLiteralsestensione era attiva. Ho pensato a quanto segue:

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

Provalo online!

Questo verrà stampato Truenormalmente e Falsealtrimenti.

Ora mi sono divertito così tanto a estendere la sfida a tutti voi. Quali altre estensioni di lingua Haskell puoi decifrare?

Regole

Per decifrare una determinata estensione del linguaggio è necessario scrivere un programma Haskell che compili sia con che senza l'estensione del linguaggio (gli avvisi vanno bene) e genera due differenti valori non di errore quando eseguito con l'estensione del linguaggio e disattivato (aggiungendo il Noprefisso a l'estensione della lingua). In questo modo il codice sopra potrebbe essere abbreviato in solo:

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

quale stampa 1e -1.

Qualsiasi metodo utilizzato per decodificare un'estensione deve essere specifico per tale estensione. Ci possono essere modi per rilevare arbitrariamente quali flag del compilatore o LanguageExtensions sono abilitate, se così non sono consentiti tali metodi. È possibile abilitare estensioni di lingua aggiuntive o modificare l'ottimizzazione del compilatore utilizzando gratuitamente -Oil conteggio dei byte.

Estensioni di lingua

Non si può rompere qualsiasi estensione linguaggio che non ha una Nocontroparte (ad esempio Haskell98, Haskell2010, Unsafe, Trustworthy, Safe) perché questi non rientrano nei termini di cui sopra. Ogni altra estensione linguistica è un gioco equo.

punteggio

Ti verrà assegnato un punto per ogni estensione di lingua che sei la prima persona a decifrare e un punto aggiuntivo per ogni estensione di lingua per cui hai il crack più breve (misurato in byte). Per il secondo punto i legami verranno interrotti a favore di precedenti invii. Il punteggio più alto è migliore

Non sarai in grado di segnare un punto per il primo invio NegativeLiteralso QuasiQuotesperché li ho già decifrati e li ho inclusi nel corpo del post. Sarai comunque in grado di segnare un punto per il crack più breve di ognuno di questi. Ecco il mio crack diQuasiQuotes

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

Provalo online!

MagicHash, 30 byte

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

-XMagicHash output 1, -XNoMagicHash output 2

MagicHash consente di terminare i nomi delle variabili in a #. Pertanto, con l'estensione, ciò definisce due funzioni y#e x#ciascuna delle quali assume un valore e restituisce una costante 2, oppure 1. x#xrestituirà 1 (perché è x#applicato a 1)

Senza l'estensione, definisce una funzione #che accetta due argomenti e restituisce 2. Il x#a=1è un modello che non viene mai raggiunto. Quindi x#xè 1#1, che restituisce 2.

CPP, 33 20 byte

main=print$0-- \
 +1

Stampa 0con -XCPPe 1con-XNoCPP .

Con -XCPP, una barra \prima di una nuova riga rimuove la nuova riga, quindi il codice diventa main=print$0-- +1e 0viene stampato solo come+1 ora fa parte del commento.

Senza il flag il commento viene ignorato e la seconda riga viene analizzata come parte della riga precedente perché è rientrata.

Approccio precedente con #define

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

Stampa anche 0con -XCPPe 1con -XNoCPP.

NumDecimals, 14 byte

main=print 1e1

-XNum Stampe decimali10 . -XNoNumDecimals stampe 10.0.

BinaryLiterals, 57 byte

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

-XBinaryLiterals stampa una nuova riga. -XNoBinaryLiterals stampa a 1.

Sono sicuro che esiste un modo migliore per farlo. Se ne trovi uno, ti preghiamo di pubblicarlo.

MonomorphismRestriction + 7 altri, 107 byte

Questo utilizza TH che richiede sempre la bandiera -XTemplateHaskell.

File T.hs, 81 + 4 byte

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

Principale, 22 byte

import T
main=print $t

Compilando con il flag MonomorphismRestriction forza il tipo di pto Integer -> Integer -> Integere quindi produce il seguente output:

"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"

Compilare con il flag NoMonomorphismRestriction lascia il tipo di ppiù generale, vale a dire. Num a => a->a->a- produrre qualcosa come (abbreviato i VarTnomi in 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"

Provali online!

alternative

Dato che il codice sopra riportato stampa semplicemente il tipo di p, questo può essere fatto con tutte le bandiere che in qualche modo influenzano il modo in cui Haskell deduce i tipi. Specifico solo il flag e con cosa sostituire la funzione pe, se necessario, flag aggiuntivi (oltre -XTemplateHaskell):

Liste sovraccariche, 106 byte

Inoltre ha bisogno di -XNoMonomorphismRestriction:

p=[]

O p :: [a]oppure p :: IsList l => l, provali online!

OverloadedStrings, 106 byte

Inoltre ha bisogno di -XNoMonomorphismRestriction:

p=""

O p :: Stringoppure p :: IsString s => s, provali online!

PolyKinds, 112 byte

Ciò è interamente dovuto a @CsongorKiss:

data P a=P 

O P :: P aoppure P :: forall k (a :: k). P a, provali online!

Comprensioni Monad, 114 byte

p x=[i|i<-x]

O p :: [a] -> [a]oppure p :: Monad m => m a -> m a, provali online!

NamedWildCards, 114 byte

Questo è stato trovato da @Laikoni, inoltre richiede -XPartialTypeSignatures:

p=id::_a->_a

Entrambi hanno il tipo di salvataggio ( p :: a -> a) ma GHC genera nomi diversi per le variabili, provali online!

ApplicativoDo, 120 byte

p x=do i<-x;pure i

O p :: Monad m => m a -> m aoppure p :: Functor f => f a -> f a, provali online!

Sovraccarico di etichette, 120 byte

Ciò richiede il flag aggiuntivo -XFlexibleContexts:

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

Digita come p :: a -> b -> bo p :: IsLabel "id" (a->b) => a -> b, provali online!

CPP, 27 25

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

Provalo online!

Stampa ()per -XCPPe 1per-XNoCPP

Versione precedente:

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

Provalo online!

Stampa [1]con -XCPPe in [1,2]altro modo.

Riconoscimenti: questo si ispira alla risposta di Laikoni, ma invece di uno #defineusa semplicemente i commenti C.

ScopedTypeVariables, 162 113 byte

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

-XScopedTypeVariables stampe ""(vuoto), -XNoScopedTypeVariables stampe "[()]".

Modifica: soluzione aggiornata grazie a suggerimenti utili nei commenti

MonoLocalBinds, GADTs o TypeFamilies, 36 32 byte

MODIFICARE:

• -4 byte: una versione di questo è stata incorporata nella grande catena poliglotta dallo stasoid, che mi ha sorpreso mettendo tutte le dichiarazioni al massimo livello. Apparentemente l'attivazione di questa restrizione non richiede vincoli locali effettivi .

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

• Con estensioni , questo programma stampa (1.0,1).

• Con una delle bandiere -XMonoLocalBinds , -XGADTs o -XTypeFamilies , stampa (1.0,1.0).

• L' MonoLocalBindsestensione esiste per impedire un'inferenza di tipo non intuitiva innescata da GADT e famiglie di tipi. Pertanto, questa estensione viene attivata automaticamente dalle altre due.

• Lo è possibile spegnerlo nuovamente esplicitamente -XNoMonoLocalBinds, questo trucco presuppone che non lo fanno.

• Come il suo cugino più noto, la restrizione del monomorfismo, MonoLocalBindsfunziona impedendo che alcuni valori ( in legami locali come leto where, quindi il nome apparentemente può capitare anche ai massimi livelli) siano polimorfici. Nonostante sia stato creato per un'inferenza di tipo più sano, le regole per quando si innesca sono possibilmente anche più pelose dell'MR.

• Senza alcuna estensione, il programma sopra menziona il tipo f :: Num a => a -> a, consentendo f pidi default a Doubleef 0 a Integer.

• Con le estensioni, il tipo inferito diventa f :: Double -> Doubleef 0 deve restituire anche un Double.
• La variabile separata a=0è necessaria per innescare le regole tecniche: aè colpita dalla restrizione del monomorfismo ed aè una variabile libera di f, il che significa che fil gruppo di legame non è completamente generalizzato , il che significa che fnon è chiuso e quindi non diventa polimorfico.

Stringhe sovraccaricate, 65 48 32 byte

Sfruttando RebindableSyntax, usa la nostra versione di fromString per trasformare qualsiasi stringa letterale in "y".

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

Deve essere compilato con -XRebindableSyntax -XImplicitPrelude.

Senza -XOverloadedStringsstampe ""; con stampe "y".

Inoltre, solo ora mi ha colpito il fatto che la stessa tecnica funziona con (ad esempio) Liste sovraccaricate:

Liste sovraccaricate, 27 byte

main=print[0]
fromListN=(:)

Deve essere compilato con -XRebindableSyntax -XImplicitPrelude.

Senza -XOverloadedListsstampe [0]; con stampe [1,0].

BangPatterns, 32 byte

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

-XBangPatterns stampa 1mentre -XNoBangPatterns stampa0 .

Questo fa uso del fatto che il flag BangPatterns consente di annotare i pattern con una !forzatura di valutazione a WHNF, in tal caso 9!1utilizzerà la definizione di livello superiore (!)=seq. Se il flag non è abilitato, f!_definisce un nuovo operatore (!)e ombreggia la definizione di livello superiore.

ApplicativoDo, 104 byte

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

Provalo online!

Con ApplicativeDo, questo stampa

ZipList {getZipList = [1]}

Senza di essa, stampa

ZipList {getZipList = []}

ZipListè uno dei pochi tipi nelle librerie di base con un'istanza per Applicativema non per Monad. Potrebbero esserci alternative più brevi in ​​agguato da qualche parte.

Rigido, 87 84 82 byte

^{-5 byte grazie a dfeuer !}

Potrebbe essere meno con il BlockArgumentssalvataggio dei genitori in giro \_->print 1:

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

Eseguire questo con -XStrict stampa a 1mentre eseguendolo con -XNoStrict verrà stampato a 0. Questo utilizza che Haskell per impostazione predefinita è pigro e non deve essere valutato error""poiché sa già che il risultato sarà0 quando corrisponderà al primo argomento di(!) , questo comportamento può essere cambiato con quel flag - costringendo il runtime a valutare entrambi gli argomenti.

Se non è consentito stampare nulla in un caso, è possibile ridurlo a 75 byte sostituendo il principale con (anche alcuni byte di dfeuer ):

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

StrictData, 106 99 93 byte

^{-15 byte grazie a dfeuer !}

Questo sostanzialmente fa lo stesso ma funziona invece con i campi dati:

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

Stampa 1con il flag -XStrictData e 0con -XNoStrictData .

Se non è consentito stampare nulla in un caso, è possibile ridurlo a 86 byte sostituendo il principale con (19 byte di dfeuer ):

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

Nota: tutte le soluzioni richiedono TypeApplicationsset.

ApplicativoDo, 146 byte

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}

Stampa 1 quando ApplicativeDo è abilitato, 0 altrimenti

Provalo online!

BinaryLiterals, 31 24 byte

Modificare:

• -7 byte: H.PWiz ha suggerito di modificarlo ulteriormente utilizzando una singola b12variabile.

Una regolazione del metodo di H.PWiz , evitando l'istanza della funzione.

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

• Con -XNoBinaryLiterals , 0b12lex come 0 b12, stampa 0 + 1 =1.
• With -XBinaryLiterals, 0b12 lexes as 0b1 2, printing 1+2 = 3.

ExtendedDefaultRules, 54 53 bytes

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

Prints () with -XExtendedDefaultRules and 0 with -XNoExtendedDefaultRules.

This flag is enabled by default in GHCi, but not in GHC, which recently caused some confusion for me, though BMO was quickly able to help.

The above code is a golfed version of an example in the GHC User Guide where type defaulting in GHCi is explained.

-1 byte thanks to Ørjan Johansen!

RebindableSyntax, 25 bytes

I was reading the recently posted Guide to GHC's Extensions when I noticed an easy one that I didn't recall seeing here yet.

main|negate<-id=print$ -1

• With -XNoRebindableSyntax, prints -1.
• With -XRebindableSyntax, prints 1.

Also requires -XImplicitPrelude, or alternatively import Prelude in the code itself.

• -XRebindableSyntax changes the behavior of some of Haskell's syntactic sugar to make it possible to redefine it.
• -1 is syntactic sugar for negate 1.
• Normally this negate is Prelude.negate, but with the extension it's "whichever negate is in scope at the point of use", which is defined as id.
• Because the extension is meant to be used to make replacements for the Prelude module, it automatically disables the usual implicit import of that, but other Prelude functions (like print) are needed here, so it is re-enabled with -XImplicitPrelude.

Strict, 52 bytes

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

-XStrict

-XNoStrict

With -XStrict, prints () an extra time.

Thanks to @Sriotchilism O'Zaic for two bytes.

StrictData, 58 bytes

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

(Links are slightly outdated; will fix.)

-XNoStrictData

-XStrictData

Requires MagicHash (to let us import GHC.Exts instead of Unsafe.Coerce) and -O (absolutely required, to enable unpacking of small strict fields).

With -XStrictData, prints 3. Otherwise, prints the integer value of the (probably tagged) pointer to the pre-allocated copy of 3::Integer, which can't possibly be 3.

Explanation

It will be a bit easier to understand with a little expansion, based on type defaulting. With signatures, we can drop the addition.

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

Equivalently,

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

Why does it ever print 3? This seems surprising! Well, small Integer values are represented very much like Ints, which (with strict data) are represented just like Ds. We end up ignoring the tag indicating whether the integer is small or large positive/negative.

Why can't it print 3 without the extension? Leaving aside any memory layout reasons, a data pointer with low bits (2 lowest for 32-bit, 3 lowest for 64-bit) of 3 must represent a value built from the third constructor. In this case, that would require a negative integer.

UnboxedTuples, 52 bytes

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

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

OverloadedLists, 76 bytes

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

With -XOverloadedLists it prints [()]. With -XNoOverloadedLists it prints []

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!