Недавно я имел удовольствие написать программу на Haskell, которая могла бы определить, NegativeLiteralsзадействовано ли расширение. Я придумал следующее:

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

Попробуйте онлайн!

Это будет печатать Trueнормально и в Falseпротивном случае.

Теперь мне было очень весело делать это, и я передал вызов всем вам. Какие еще расширения языка Haskell вы можете взломать?

правила

Чтобы взломать конкретное расширение языка, вы должны написать программу на 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) , потому что они не попадают в соответствии с условиями , изложенными выше. Любое другое языковое расширение является честной игрой.

счет

Вам будет начислено одно очко за каждое расширение языка, которое вы взломали первым, и одно дополнительное очко за каждое расширение языка, для которого у вас самый короткий взлом (измеренный в байтах). По второму пункту связи будут нарушены в пользу более ранних представлений. Чем выше балл, тем лучше

Вы не сможете набрать очко за первую отправку 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#xвернет 1 (потому что он x#применяется к 1)

Без расширения это определяет одну функцию, #которая принимает два аргумента и возвращает 2. Это x#a=1шаблон, который никогда не будет достигнут. Тогда x#xесть 1#1, который возвращает 2.

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.

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

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

Попробуйте их онлайн!

альтернативы

Поскольку приведенный выше код просто выводит тип p, это можно сделать со всеми флагами, которые каким-то образом влияют на то, как Haskell выводит типы. Я буду только указывать флаг и на что заменить функцию pи при необходимости дополнительные флаги (кроме -XTemplateHaskell):

Перегруженные списки, 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, попробовать их в Интернете!

Перегруженные метки, 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он просто использует комментарии С.

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Расширение существует , чтобы предотвратить некоторое неинтуитивное умозаключение типа , спровоцированный GADTs и семьями типа. Таким образом, это расширение автоматически включается двумя другими.

• Это есть возможность отключить его снова в явном виде с -XNoMonoLocalBinds, этот прием предполагает , что вы не делаете.

• Как и его более известный двоюродный брат, ограничение мономорфизма MonoLocalBindsработает, предотвращая некоторые значения ( в локальных привязках, таких как letилиwhere полиморфность , таким образом, название, по- видимому, также может происходить на верхнем уровне). Несмотря на то, что они созданы для логического вывода, правила, когда это срабатывает , по возможности, даже более пугающие, чем MR.

• Без какого-либо расширения, вышеуказанная программа выводит тип f :: Num a => a -> a, позволяяf pi по умолчанию a Doubleи f 0a Integer.

• С расширениями выведенный тип становится f :: Double -> Double и f 0должен возвращатьDouble .
• Отдельные переменная a=0необходима , чтобы вызвать технические правила: aудар по ограничению мономорфизма, и aявляется свободным переменным из 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 байта

^{-5 байт благодаря dfeuer !}

Может быть меньше с BlockArgumentsсохранением паренов вокруг \_->print 1:

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

Выполнение этого с -XStrict печатает a, 1тогда как выполнение этого с -XNoStrict будет печатать a 0. При этом используется то, что Haskell по умолчанию является ленивым и не нуждается в оценке, error""так как он уже знает, что результат будет, 0когда он соответствует первому аргументу(!) этого результата это поведение можно изменить с помощью этого флага, что заставит среду выполнения оценить оба аргумента.

Если в одном случае разрешено ничего не печатать, мы можем уменьшить его до 75 байт, заменив основной на (также некоторые байты отключены dfeuer ):

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

StrictData, 106 99 93 байта

^{-15 байт благодаря dfeuer !}

Это в основном то же самое, но вместо этого работает с полями данных:

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

Печать 1с флагом -XStrictData и 0с -XNoStrictData .

Если в одном случае разрешено печатать ничего, мы можем уменьшить его до 86 байт, заменив основной на (19 байтов выключено dfeuer ):

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}

Печатает 1, когда ApplicativeDo включен, 0 в противном случае

Попробуйте онлайн!

BinaryLiterals, 31 24 байта

Редактировать:

• -7 байт: H.PWiz предложил откорректировать его, используя один b12 переменную.

Корректировка метода H.PWiz , избегая экземпляра функции.

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

• С -XNoBinaryLiterals , лекс0b12 как0 b12 , печать 0 + 1 = 1.
• С -XBinaryLiterals , лекс0b12 как 0b1 2, печать 1 + 2 = 3.

ExtendedDefaultRules, 54 53 байта

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

Печать ()с -XExtendedDefaultRulesи 0с -XNoExtendedDefaultRules.

Этот флаг включен по умолчанию в GHCi, но не в GHC, что недавно вызвало у меня некоторую путаницу , хотя BMO быстро помогло.

Приведенный выше код является версией для гольфа, приведенной в примере в Руководстве пользователя GHC, где поясняется тип по умолчанию в GHCi .

-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, печатает ()дополнительное время.

Спасибо @Sriotchilism О'Зайку за два байта.

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, которая не может быть 3.

объяснение

Это будет немного легче понять с небольшим расширением, основанным на типе по умолчанию. С помощью подписей мы можем отказаться от сложения.

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

Эквивалентное

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

Почему он печатает 3? Это кажется удивительным! Ну, маленькие Integerзначения представлены очень похоже на Ints, которые (со строгими данными) представлены так же, как Ds. В итоге мы игнорируем тег, указывающий, является ли целое число маленьким или большим положительным / отрицательным.

Почему он не может напечатать 3 без расширения? Оставляя в стороне любые причины размещения памяти, указатель данных с младшими битами (2 младших для 32-битных, 3 младших для 64-битных), равный 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 байт

-24 байта благодаря Орджану Йохансену.

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

Печать 0.0с -XHexFloatLiteralsи 0с -XNoHexFloatLiterals.

Нет ссылок на TIO, потому что HexFloatLiterals был добавлен в ghc 8.4.1, но 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 ()

С переменными типа scoped тип ain 1должен быть aтипом in main, который сам должен быть Float. Без переменных типа с областью видимости по 1умолчанию Integer. Так как Floatи Integerзначения отображаются по-разному, мы можем их различать.

Спасибо @ ÖrjanJohansen за колоссальные 19 байтов! Он понял, что гораздо лучше использовать разницу между Showэкземплярами разных числовых типов, чем различия в их арифметике. Он также понял, что было бы нормально оставить тип main«синтаксически неоднозначным», потому что ограничение фактически устраняет его. Избавление от локальной функции также освободило меня от удаления сигнатуры типа для main(смещения ее в 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 является стратегией по умолчанию, когда включены и DeriveAnyClass, и GeneralizedNewtypeDeriving, как вы можете видеть из предупреждений. Этот флаг будет счастливо генерировать пустые реализации для всех методов , но 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 за понимание, что я мог использовать idвместо пользовательского оператора, сохраняя четыре байта.

DeriveAnyClass, 104 байта

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

Попробуйте онлайн (без расширения)

Попробуйте онлайн (с расширением)

Также требуется GeneralizedNewtypeDeriving.

StrictData, 97 байт

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

Попробуйте онлайн (без строгих данных)

Попробуйте онлайн (строгие данные)

Также требуется DeriveGeneric.

UnicodeSyntax, 33 байта

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

Попробуйте онлайн!

TemplateHaskell, 140 91 байт

Просто скопировал с mauke с небольшими изменениями. Я не знаю, что происходит.

-49 байтов благодаря Орджану Йохансену.

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

Попробуйте онлайн!

MonomorphismRestriction, 31 29 байт

Редактировать:

• -2 байта с улучшением от H.PWiz

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

-XMonomorphismRestriction печатает 0. -XNoMonomorphismRestriction печатает18446744073709551616 .

• С ограничением, оба использования fпринудительно должны быть одного типа, поэтому программа печатает 2^2^6 = 2^64как 64-битныйInt (на 64-битных платформах), которая переполняется до0 .
• Без ограничений программа печатает 2^64как бигнум Integer.

ScopedTypeVariables, 119 97 байт

Просто скопировал с mauke с небольшими изменениями.

В настоящее время есть два других ответа для ScopedTypeVariables: 113 байтов Csongor Kiss и 37 байтов dfeuer . Это представление отличается тем, что не требует других расширений Haskell.

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

Попробуйте онлайн!