Recentemente, tive o prazer de escrever um programa Haskell que pudesse detectar se a NegativeLiteralsextensão estava envolvida. Eu vim com o seguinte:

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

Experimente online!

Isso será impresso Truenormalmente e Falsecaso contrário.

Agora eu me diverti muito fazendo isso, estou estendendo o desafio para todos vocês. Quais outras extensões de idioma Haskell você pode quebrar?

Regras

Para quebrar uma extensão de idioma específica, você deve escrever um programa Haskell que compila com e sem a extensão de idioma (os avisos são bons) e gera dois valores diferentes de erro quando executados com a extensão de idioma e desativados (adicionando o Noprefixo a a extensão do idioma). Dessa maneira, o código acima pode ser reduzido para apenas:

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

que imprime 1e -1.

Qualquer método usado para quebrar uma extensão deve ser específico a essa extensão. Pode haver maneiras de detectar arbitrariamente quais sinalizadores do compilador ou LanguageExtensions estão habilitados, se esses métodos não forem permitidos. Você pode ativar extensões de idioma adicionais ou alterar a otimização do compilador usando -Osem nenhum custo a sua contagem de bytes.

Extensões de idioma

Você não pode quebrar qualquer extensão de linguagem que não tem uma Nocontrapartida (por exemplo Haskell98, Haskell2010, Unsafe, Trustworthy, Safe) porque estas não se enquadram nos termos descritos acima. Qualquer outra extensão de idioma é um jogo justo.

Pontuação

Você receberá um ponto por cada extensão de idioma que você é a primeira pessoa a quebrar e um ponto adicional por cada extensão de idioma para a qual você tem o menor crack (medido em bytes). Para o segundo ponto, os laços serão quebrados em favor de envios anteriores. Maior pontuação é melhor

Você não poderá marcar um ponto para a primeira submissão NegativeLiteralsou QuasiQuotesporque eu já os decifrei e os incluí no corpo da postagem. No entanto, você será capaz de marcar um ponto pelo menor crack de cada um deles. Aqui está o meu crackQuasiQuotes

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

Experimente online!

MagicHash, 30 bytes

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

-XMagicHash gera 1, -XNoMagicHash gera 2

MagicHash permite que nomes de variáveis ​​terminem em a #. Portanto, com a extensão, isso define duas funções y#e x#cada uma pega um valor e retorna uma constante 2, ou 1. x#xretornará 1 (porque éx# aplicado a 1)

Sem a extensão, isso define uma função #que recebe dois argumentos e retorna 2. O x#a=1é um padrão que nunca é alcançado. Então x#xé 1#1, que retorna 2.

CPP, 33 20 bytes

main=print$0-- \
 +1

Imprime 0com -XCPPe 1com-XNoCPP .

Com -XCPP, uma barra \antes de uma nova linha remove a nova linha, assim o código se torna main=print$0-- +1e somente 0é impresso como o+1 agora faz parte do comentário.

Sem a sinalização, o comentário é ignorado e a segunda linha é analisada como parte da linha anterior, porque é recuada.

Abordagem anterior com #define

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

Também imprime 0com -XCPPe 1com-XNoCPP .

NumDecimals, 14 bytes

main=print 1e1

-XNumDecimals imprime 10. -XNoNumDecimals imprime 10.0.

Literais binários, 57 bytes

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

-XBinaryLiterals imprime uma única nova linha. -XNoBinaryLiterals imprime a 1.

Estou certo de que existe uma maneira melhor de fazer isso. Se você encontrar um, por favor poste.

MonomorfismoRestrição + 7 others, 107 bytes

Isso usa TH, que requer a bandeira o -XTemplateHaskelltempo todo.

Arquivo T.hs, 81 + 4 bytes

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

Principal, 22 bytes

import T
main=print $t

Compilar com o sinalizador MonomorphismRestriction força o tipo de ppara Integer -> Integer -> Integere, portanto, produz a seguinte saída:

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

Compilar com a bandeira NoMonomorphismRestriction deixa o tipo dep no mais geral, ie. Num a => a->a->a- produzindo algo como (reduziu os VarTnomes para 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"

Experimente-os online!

Alternativas

Como o código acima simplesmente imprime o tipo de p, isso pode ser feito com todos os sinalizadores que de alguma forma influenciam a maneira como Haskell deduz os tipos. Especificarei apenas o sinalizador e com o que substituir a função pe, se necessário, sinalizadores adicionais (além de-XTemplateHaskell ):

OverloadedLists, 106 bytes

Além disso precisa -XNoMonomorphismRestriction:

p=[]

Ou , p :: [a]oup :: IsList l => lexperimentá-los online!

OverloadedStrings, 106 bytes

Além disso precisa -XNoMonomorphismRestriction:

p=""

De qualquer p :: Stringou p :: IsString s => s, experimentá-los online!

PolyKinds, 112 bytes

Isso se deve inteiramente ao @CsongorKiss:

data P a=P 

De qualquer P :: P aou P :: forall k (a :: k). P a, experimentá-los online!

MônadasCompreensões, 114 bytes

p x=[i|i<-x]

De qualquer p :: [a] -> [a]ou p :: Monad m => m a -> m a, experimentá-los online!

NamedWildCards, 114 bytes

Este foi encontrado pelo @Laikoni, além disso requer -XPartialTypeSignatures:

p=id::_a->_a

Ambos têm o tipo save ( p :: a -> a), mas o GHC gera nomes diferentes para as variáveis, experimente-os online!

ApplicativeDo, 120 bytes

p x=do i<-x;pure i

De qualquer p :: Monad m => m a -> m aou p :: Functor f => f a -> f a, experimentá-los online!

OverloadedLabels, 120 bytes

Isso precisa do sinalizador adicional -XFlexibleContexts:

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

Escreva como p :: a -> b -> bou p :: IsLabel "id" (a->b) => a -> b, experimente-os online!

CPP, 27 25

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

Experimente online!

Imprime ()para -XCPPe 1para-XNoCPP

Versão anterior:

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

Experimente online!

Impressões [1] com-XCPP e de [1,2]outra forma.

Créditos: isso é inspirado na resposta de Laikoni, mas em vez de #definesimplesmente usa comentários em C.

ScopedTypeVariables, 162 113 bytes

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

-XScopedTypeVariables imprime ""(vazio), -XNoScopedTypeVariables imprime"[()]" .

Edit: solução atualizada graças a sugestões úteis nos comentários

MonoLocalBinds, GADTs ou TypeFamilies, 36 32 bytes

EDITAR:

• -4 bytes: Uma versão disso foi incorporada à grande cadeia poliglota pela stasoid, que me surpreendeu ao colocar todas as declarações em nível superior. Aparentemente, acionar essa restrição não requer ligações locais reais .

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

• Sem extensões , este programa é impresso (1.0,1).

• Com qualquer um dos sinalizadores -XMonoLocalBinds , -XGADTs ou -XTypeFamilies , ele imprime(1.0,1.0) .

• o MonoLocalBinds extensão existe para evitar alguma inferência de tipo não intuitiva acionada por GADTs e famílias de tipos. Como tal, esta extensão é ativada automaticamente pelas outras duas.

• Ele é possível desligá-lo novamente de forma explícita com-XNoMonoLocalBinds , este truque assume que você não.

• Como seu primo mais conhecido, a restrição de monomorfismo, MonoLocalBindsfunciona impedindo que alguns valores ( em ligações locais como letou where, portanto, o nome aparentemente também possa acontecer em nível superior) sejam polimórficos. Apesar de terem sido criadas para inferência de tipo mais saudável, as regras para quando são acionadas são, se possível, ainda mais peludas que a RM.

• Sem qualquer extensão, os infere programa acima o tipo f :: Num a => a -> a, permitindo que f pipara o padrão para um Doublee f 0para um Integer.

• Com as extensões, o tipo inferido se torna f :: Double -> Doubleef 0 também deve retornar um Double.
• A variável separada a=0é necessária para acionar as regras técnicas: aé atingida pela restrição de monomorfismo e aé uma variável livre de f, o que significa que fo grupo de ligação desse grupo não é totalmente generalizado , o que significa que fnão é fechado e, portanto, não se torna polimórfico.

OverloadedStrings, 65 48 32 bytes

Aproveitando o RebindableSyntax, use nossa própria versão do fromString para transformar qualquer string literal em "y".

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

Deve ser compilado com -XRebindableSyntax -XImplicitPrelude .

Sem -XOverloadedStringsimpressões ""; com estampas"y".

Além disso, apenas agora me ocorreu que a mesma técnica funciona com (por exemplo) OverloadedLists:

OverloadedLists, 27 bytes

main=print[0]
fromListN=(:)

Deve ser compilado com -XRebindableSyntax -XImplicitPrelude .

Sem -XOverloadedListsimpressões [0]; com impressões [1,0].

BangPatterns, 32 bytes

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

-XBangPatterns imprime 1enquanto -XNoBangPatterns imprime 0.

Isso faz com que o sinalizador BangPatterns permita anotar padrões com um !para forçar a avaliação ao WHNF; nesse caso 9!1, usará a definição de nível superior (!)=seq. Se o sinalizador não estiver ativado, f!_define um novo operador (!)e oculta a definição de nível superior.

ApplicativeDo, 104 bytes

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

Experimente online!

Com ApplicativeDo, isso imprime

ZipList {getZipList = [1]}

Sem ele, imprime

ZipList {getZipList = []}

ZipListé um dos poucos tipos nas bibliotecas base com uma instância para, Applicativemas não para Monad. Pode haver alternativas mais curtas à espreita em algum lugar.

Rigoroso, 87 84 82 bytes

^{-5 bytes graças ao dfeuer !}

Pode ser menos com o BlockArgumentssalvamento dos parênteses \_->print 1:

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

A execução com -XStrict imprime um, 1enquanto a execução com -XNoStrict imprime a 0. Isso usa que Haskell, por padrão, é preguiçoso e não precisa avaliar, error""pois já sabe que o resultado será 0quando corresponder ao primeiro argumento de (!), esse comportamento pode ser alterado com esse sinalizador - forçando o tempo de execução a avaliar os dois argumentos.

Se não for permitido imprimir nada em um caso, podemos reduzi -lo a 75 bytes, substituindo o principal por (também alguns bytes desativados pelo dfeuer ):

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

StrictData, 106 99 93 bytes

^{-15 bytes graças ao dfeuer !}

Isso basicamente faz o mesmo, mas funciona com campos de dados:

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

Imprime 1com o sinalizador -XStrictData e 0com -XNoStrictData .

Se nada for permitido em um caso, podemos reduzi -lo para 86 bytes, substituindo o principal por (19 bytes desativados pelo dfeuer ):

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

Nota: Todas as soluções requerem TypeApplicationsconjunto.

ApplicativeDo, 146 bytes

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}

Prints 1 when ApplicativeDo is enabled, 0 otherwise

Try it online!

BinaryLiterals, 31 24 bytes

Edit:

• -7 bytes: H.PWiz suggested adjusting it further by using a single b12 variable.

An adjustment to H.PWiz's method, avoiding the function instance.

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

• With -XNoBinaryLiterals, 0b12 lexes as 0 b12, printing 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!