Kürzlich hatte ich das Vergnügen, ein Haskell-Programm zu schreiben, das erkennen konnte, ob die NegativeLiteralsErweiterung belegt war. Ich habe mir folgendes ausgedacht:

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

Probieren Sie es online!

Dies wird Truenormal und Falseansonsten gedruckt .

Jetzt hatte ich so viel Spaß dabei, dass ich die Herausforderung auf euch alle ausdehne. Welche anderen Haskell-Spracherweiterungen können Sie knacken?

Regeln

Um eine bestimmte Spracherweiterung zu knacken, müssen Sie ein Haskell-Programm schreiben, das mit und ohne Spracherweiterung kompiliert (Warnungen sind in Ordnung) und zwei verschiedene fehlerfreie Werte ausgibt , wenn es mit der Spracherweiterung ausgeführt und deaktiviert wird (durch Hinzufügen des NoPräfixes zu) die Spracherweiterung). Auf diese Weise könnte der obige Code auf Folgendes gekürzt werden:

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

welche druckt 1und -1.

Jede Methode, die Sie zum Knacken einer Erweiterung verwenden, muss für diese Erweiterung spezifisch sein. Es kann Möglichkeiten geben, willkürlich festzustellen, welche Compiler-Flags oder LanguageExtensions aktiviert sind, wenn solche Methoden nicht zulässig sind. Sie können zusätzliche Spracherweiterungen aktivieren oder die Compileroptimierung kostenlos -Oan Ihrer Byteanzahl ändern .

Spracherweiterungen

Sie können keine Spracherweiterung knacken, der keinen hat NoGegenstück (zB Haskell98, Haskell2010, Unsafe, Trustworthy, Safe) , da diese nicht unter den oben genannten Bedingungen fallen. Jede andere Spracherweiterung ist Freiwild.

Wertung

Sie erhalten einen Punkt für jede Spracherweiterung, die Sie als erste Person knacken, und einen zusätzlichen Punkt für jede Spracherweiterung, für die Sie den kürzesten (gemessen in Byte) Riss haben. Für den zweiten Punkt werden die Bande zugunsten früherer Einreichungen unterbrochen. Eine höhere Punktzahl ist besser

Sie können keinen Punkt für die erste Einreichung erzielen, NegativeLiteralsoder QuasiQuotesweil ich sie bereits geknackt und in den Inhalt des Beitrags aufgenommen habe. Sie werden jedoch in der Lage sein, einen Punkt für den kürzesten Riss von jedem von diesen zu erzielen. Hier ist mein Riss vonQuasiQuotes

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

Probieren Sie es online!

MagicHash, 30 Bytes

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

-XMagicHash gibt 1 aus, -XNoMagicHash gibt 2 aus

Mit MagicHash können Variablennamen in a enden #. Daher mit der Erweiterung definiert diese beiden Funktionen y#und x#die jeweils einen Wert annehmen , und eine konstante Rück 2oder 1. x#xgibt 1 zurück (weil es x#angewendet wird 1)

Ohne die Erweiterung wird eine Funktion definiert, #die zwei Argumente akzeptiert und zurückgibt 2. Das x#a=1ist ein Muster, das niemals erreicht wird. Dann x#xist 1#1, was 2 zurückgibt.

CPP, 33 20 Bytes

main=print$0-- \
 +1

Druckt 0mit -XCPPund 1mit -XNoCPP.

Mit -XCPPeinem Schrägstrich \vor einer neuen Zeile wird die neue Zeile entfernt, so dass der Code main=print$0-- +1nur 0gedruckt wird, wenn er +1jetzt Teil des Kommentars ist.

Ohne das Flag wird der Kommentar ignoriert und die zweite Zeile wird als Teil der vorherigen Zeile analysiert, da sie eingerückt ist.

Vorheriger Ansatz mit #define

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

Druckt auch 0mit -XCPPund 1mit -XNoCPP.

NumDecimals, 14 Bytes

main=print 1e1

-XNumDecimals druckt 10. -XNoNumDecimals druckt 10.0.

BinaryLiterals, 57 Bytes

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

-XBinaryLiterals gibt eine einzelne neue Zeile aus. -XNoBinaryLiterals druckt a 1.

Ich bin sicher, es gibt einen besseren Weg, dies zu tun. Wenn Sie einen finden, posten Sie ihn bitte.

MonomorphismRestriction + 7 andere, 107 Bytes

Dies verwendet TH, wofür das Flag immer benötigt wird -XTemplateHaskell.

Datei T.hs, 81 + 4 Bytes

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

Haupt, 22 Bytes

import T
main=print $t

Das Kompilieren mit dem Flag MonomorphismRestriction erzwingt den Typ von pto Integer -> Integer -> Integerund erzeugt somit die folgende Ausgabe:

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

Beim Kompilieren mit dem Flag NoMonomorphismRestriction bleibt der Typ von pam allgemeinsten, d. H. Num a => a->a->a- Herstellung von etwas wie (die VarTNamen verkürzt 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"

Probiere sie online aus!

Alternativen

Da der obige Code einfach den Typ von pausgibt, kann dies mit allen Flags erfolgen, die irgendwie Einfluss darauf haben, wie Haskell Typen ableitet. Ich werde nur das Flag angeben und womit die Funktion zu ersetzen ist pund ggf. zusätzliche Flags (nebenbei -XTemplateHaskell):

OverloadedLists, 106 Bytes

Benötigt zusätzlich -XNoMonomorphismRestriction:

p=[]

Entweder p :: [a]oder p :: IsList l => l, versuchen Sie sie online!

OverloadedStrings, 106 Bytes

Benötigt zusätzlich -XNoMonomorphismRestriction:

p=""

Entweder p :: Stringoder p :: IsString s => s, versuchen Sie sie online!

PolyKinds, 112 Bytes

Dies ist ausschließlich @CsongorKiss zu verdanken:

data P a=P 

Entweder P :: P aoder P :: forall k (a :: k). P a, versuchen Sie sie online!

MonadComprehensions, 114 Byte

p x=[i|i<-x]

Entweder p :: [a] -> [a]oder p :: Monad m => m a -> m a, versuchen Sie sie online!

NamedWildCards, 114 Bytes

Diese wurde von @Laikoni gefunden und benötigt zusätzlich -XPartialTypeSignatures:

p=id::_a->_a

Beide haben den Speichertyp ( p :: a -> a), aber GHC generiert unterschiedliche Namen für die Variablen. Probieren Sie sie online aus!

ApplicativeDo, 120 Byte

p x=do i<-x;pure i

Entweder p :: Monad m => m a -> m aoder p :: Functor f => f a -> f a, versuchen Sie sie online!

OverloadedLabels, 120 Byte

Dies benötigt das zusätzliche Flag -XFlexibleContexts:

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

Entweder Typen wie p :: a -> b -> boder p :: IsLabel "id" (a->b) => a -> b, versuchen Sie sie online!

CPP, 27 25

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

Probieren Sie es online!

Drucke ()für -XCPPund 1für-XNoCPP

Vorherige Version:

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

Probieren Sie es online!

Druckt [1]mit -XCPPund [1,2]anders.

Credits: Dies ist von der Antwort von Laikoni inspiriert, verwendet aber statt eines #defineeinfach C-Kommentare.

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 druckt ""(leer), -XNoScopedTypeVariables druckt "[()]".

Edit: aktualisierte Lösung dank nützlicher Vorschläge in den Kommentaren

MonoLocalBinds, GADTs oder TypeFamilies, 36 32 Bytes

BEARBEITEN:

• -4 Bytes: Eine Version davon wurde von stasoid in die große polyglotte Kette aufgenommen, die mich überraschte, indem sie alle Deklarationen auf die oberste Ebene stellte. Anscheinend erfordert das Auslösen dieser Einschränkung keine tatsächlichen lokalen Bindungen.

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

• Mit ohne Erweiterungen , druckt dieses Programm (1.0,1).

• Mit den Flags -XMonoLocalBinds , -XGADTs oder -XTypeFamilies wird gedruckt (1.0,1.0).

• Die MonoLocalBindsErweiterung soll verhindern, dass durch GADTs und Typfamilien eine nicht intuitive Typinferenz ausgelöst wird. Daher wird diese Erweiterung von den beiden anderen automatisch aktiviert.

• Es ist möglich, es explizit mit wieder auszuschalten -XNoMonoLocalBinds, dieser Trick geht davon aus, dass Sie dies nicht tun.

• Wie seine bekanntere Cousine, die Monomorphismus-Beschränkung, MonoLocalBindsverhindert sie, dass einige Werte ( in lokalen Bindungen wie letoder where, daher kann der Name anscheinend auch auf oberster Ebene vorkommen) polymorph sind. Die Regeln für den Zeitpunkt der Auslösung sind, obwohl sie für eine genauere Typinferenz erstellt wurden, nach Möglichkeit noch haariger als die MR.

• Das obige Programm fügt den Typ ohne Erweiterung ein und f :: Num a => a -> aerlaubt f pistandardmäßig a Doubleund f 0an Integer.

• Mit den Erweiterungen wird der Typ abgeleitet f :: Double -> Doubleund f 0muss Doubleauch a zurückgeben.
• Die separate Variable a=0wird benötigt, um die technischen Regeln auszulösen: aWird von der Monomorphismus-Beschränkung getroffen und aist eine freie Variable von f, was bedeutet, dass fdie Bindungsgruppe nicht vollständig verallgemeinert ist , dh fnicht geschlossen ist und daher nicht polymorph wird.

OverloadedStrings, 65 48 32 Bytes

Verwenden Sie unter Ausnutzung von RebindableSyntax unsere eigene Version von fromString, um jedes String-Literal in zu verwandeln "y".

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

Muss mit kompiliert werden -XRebindableSyntax -XImplicitPrelude.

Ohne -XOverloadedStringsDrucke ""; mit drucke "y".

Außerdem ist mir erst jetzt aufgefallen, dass die gleiche Technik mit (zB) OverloadedLists funktioniert:

OverloadedLists, 27 Bytes

main=print[0]
fromListN=(:)

Muss mit kompiliert werden -XRebindableSyntax -XImplicitPrelude.

Ohne -XOverloadedListsDrucke [0]; mit drucke [1,0].

BangPatterns, 32 Bytes

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

-XBangPatterns druckt 1während -XNoBangPatterns druckt 0.

Dies macht Gebrauch davon, dass das Flag BangPatterns erlaubt, Muster mit Anmerkungen zu versehen !, um die Auswertung an WHNF zu erzwingen. In diesem Fall 9!1wird die Definition der obersten Ebene verwendet (!)=seq. Wenn das Flag nicht aktiviert f!_ist, wird ein neuer Operator definiert (!)und die Definition der obersten Ebene abgeschattet.

ApplicativeDo, 104 Byte

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

Probieren Sie es online!

Mit ApplicativeDowird dies gedruckt

ZipList {getZipList = [1]}

Ohne es druckt es

ZipList {getZipList = []}

ZipListist einer der wenigen Typen in den Basisbibliotheken mit einer Instanz für, Applicativeaber nicht für Monad. Es kann kürzere Alternativen geben, die irgendwo lauern.

Streng, 87 84 82 Bytes

^{-5 bytes dank dfeuer !}

Könnte weniger mit dem BlockArgumentsSpeichern der Eltern herum sein \_->print 1:

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

Wird dies mit -XStrict ausgeführt, wird ein ausgegeben , 1während bei Ausführung mit -XNoStrict ein ausgegeben wird 0. In diesem Fall ist Haskell standardmäßig faul und muss nicht ausgewertet werden, error""da bereits bekannt ist, dass das Ergebnis 0bei Übereinstimmung mit dem ersten Argument von angezeigt wird. (!)Dieses Verhalten kann mit diesem Flag geändert werden, sodass die Laufzeit beide Argumente auswerten muss.

Wenn in einem Fall nichts gedruckt werden darf, können wir es auf 75 Bytes reduzieren , indem wir das Hauptbyte ersetzen (auch einige Bytes von dfeuer ):

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

StrictData, 106 99 93 Bytes

^{-15 bytes dank dfeuer !}

Dies funktioniert im Prinzip genauso, funktioniert jedoch stattdessen mit Datenfeldern:

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

Druck 1mit der -XStrictData Flagge und 0mit -XNoStrictData .

Wenn in einem Fall nichts gedruckt werden darf, können wir es auf 86 Bytes reduzieren, wobei das Hauptbyte durch (19 Bytes durch dfeuer ) ersetzt wird:

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

Hinweis: Alle Lösungen müssen TypeApplicationsfestgelegt werden.

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}

Gibt 1 aus, wenn ApplicativeDo aktiviert ist, andernfalls 0

Probieren Sie es online!

BinaryLiterals, 31 24 Bytes

Bearbeiten:

• -7 Bytes: H.PWiz schlug vor, die Einstellung mithilfe einer einzelnen b12Variablen weiter anzupassen .

Eine Anpassung der Methode von H.PWiz unter Vermeidung der Funktionsinstanz.

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

• Mit -XNoBinaryLiterals wird 0b12lexes as 0 b12mit 0 + 1 = ausgegeben 1.
• Mit -XBinaryLiterals wird 0b12lexes as 0b1 2mit 1 + 2 = ausgegeben 3.

ExtendedDefaultRules, 54 53 Bytes

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

Druckt ()mit -XExtendedDefaultRulesund 0mit -XNoExtendedDefaultRules.

Dieses Flag ist standardmäßig in GHCi aktiviert, aber nicht in GHC, was kürzlich einige Verwirrung bei mir ausgelöst hat , obwohl BMO schnell helfen konnte.

Der obige Code ist eine Golfversion eines Beispiels im GHC-Benutzerhandbuch, in dem der in GHCi voreingestellte Typ erläutert wird.

-1 Byte danke an Ørjan Johansen !

RebindableSyntax , 25 Byte

Ich habe gerade den kürzlich veröffentlichten Leitfaden zu den Erweiterungen von GHC gelesen, als mir ein einfacher Leitfaden aufgefallen ist, den ich hier noch nicht gesehen habe.

main|negate<-id=print$ -1

• Mit -XNoRebindableSyntax wird gedruckt -1.
• Mit -XRebindableSyntax wird gedruckt 1.

Benötigt -XImplicitPreludeauch oder alternativ import Preludeim Code selbst.

• -XRebindableSyntax ändert das Verhalten einiger syntaktischer Zucker von Haskell, um eine Neudefinition zu ermöglichen.
• -1ist syntaktischer Zucker für negate 1.
• Normalerweise dies negateist Prelude.negate, aber mit der Erweiterung ist es „je nachdem , was negatean der Verwendungsstelle in ihrem Umfang ist“, die definiert ist als id.
• Da die Erweiterung zum Ersetzen des PreludeModuls verwendet werden soll, wird der normale implizite Import des Moduls automatisch deaktiviert, jedoch werden hier andere PreludeFunktionen (wie print) benötigt, sodass es mit erneut aktiviert wird -XImplicitPrelude.

Streng, 52 Bytes

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

-XStrict

-XNoStrict

Mit -XStrictwird ()eine zusätzliche Zeit gedruckt .

Vielen Dank an @Sriotchilism O'Zaic für zwei Bytes.

StrictData, 58 Bytes

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

(Links sind etwas veraltet; wird behoben.)

-XNoStrictData

-XStrictData

Benötigt MagicHash( GHC.Extsstatt importieren zu lassen Unsafe.Coerce) und -O(unbedingt erforderlich, um das Auspacken kleiner, strenger Felder zu ermöglichen).

Mit -XStrictDatawird 3 ausgegeben. Andernfalls wird der ganzzahlige Wert des (wahrscheinlich gekennzeichneten) Zeigers auf die vorab zugewiesene Kopie von gedruckt 3::Integer, die möglicherweise nicht 3 sein kann.

Erläuterung

Es wird ein bisschen einfacher, mit einer kleinen Erweiterung zu verstehen, basierend auf dem Standardtyp. Mit Unterschriften können wir den Zusatz verwerfen.

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

Äquivalent dazu

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

Warum druckt es jemals 3? Das scheint überraschend! Nun, kleine IntegerWerte werden sehr ähnlich wie Ints dargestellt, die (mit strengen Daten) genau wie Ds dargestellt werden. Am Ende ignorieren wir das Tag, das angibt, ob die Ganzzahl klein oder groß positiv / negativ ist.

Warum kann 3 nicht ohne die Erweiterung gedruckt werden? Abgesehen von Speicherlayoutgründen muss ein Datenzeiger mit niedrigen Bits (2 niedrigste für 32-Bit, 3 niedrigste für 64-Bit) von 3 einen Wert darstellen, der aus dem dritten Konstruktor erstellt wurde. In diesem Fall würde dies eine negative ganze Zahl erfordern .

UnboxedTuples, 52 Bytes

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

Benötigt -XTemplateHaskell. Drucke ConE GHC.Prim.(##)mit -XUnboxedTuples und UnboundVarE ##mit -XNoUnboxedTuples .

OverloadedLists, 76 Bytes

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

Mit -XOverloadedLists wird gedruckt [()]. Mit -XNoOverloadedLists wird gedruckt[]

Dies erfordert die zusätzliche Fahnen: -XFlexibleInstances,-XIncoherentInstances

HexFloatLiterals , 49 25 Bytes

-24 Bytes dank Ørjan Johansen.

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

Druckt 0.0mit -XHexFloatLiteralsund 0mit -XNoHexFloatLiterals.

Es gibt keine TIO-Links, da HexFloatLiterals in Ghc 8.4.1 hinzugefügt wurde, TIO jedoch Ghc 8.2.2.

ScopedTypeVariables, 37 Byte

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

Dies erfordert auch UnicodeSyntax, PartialTypeSignatures, GADTs, und ExplicitForAll.

Probieren Sie es online (ohne Erweiterung)

Probieren Sie es online (mit Erweiterung)

Erläuterung

Die partiellen Typ-Signaturen dienen nur zum Speichern von Bytes. Wir können sie folgendermaßen ausfüllen:

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

Mit scoped Typ Variablen, die avon in der Art 1beschränkt ist , die zu sein ain der Art der main, der sich gezwungen ist , zu sein Float. Ohne Typvariablen mit Gültigkeitsbereich wird 1standardmäßig der Typ verwendet Integer. Da Floatund IntegerWerte unterschiedlich dargestellt werden, können wir sie unterscheiden.

Vielen Dank an @ ØrjanJohansen für satte 19 Bytes! Er erkannte, dass es viel besser war, den Unterschied zwischen ShowInstanzen verschiedener numerischer Typen auszunutzen, als Unterschiede in ihrer Arithmetik. Er erkannte auch, dass es in Ordnung war, den Typ main"syntaktisch mehrdeutig" zu belassen, da die Einschränkung ihn tatsächlich eindeutig macht. Durch das Entfernen der lokalen Funktion konnte ich auch die Typensignatur für entfernen main(auf RHS verschieben), um fünf weitere Bytes zu sparen.

DeriveAnyClass, 121 113 Bytes

^{Danke an dfeuer für etliche Bytes!}

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

-XDeriveAnyClass druckt, 1wohingegen -XNoDeriveAnyClass druckt M 0.

Dies nutzt die Tatsache aus, dass DeriveAnyClass die Standardstrategie ist, wenn DeriveAnyClass und GeneralizedNewtypeDeriving aktiviert sind, wie Sie anhand der Warnungen sehen können. Dieses Flag generiert problemlos leere Implementierungen für alle Methoden, aber GeneralizedNewtypeDeriving ist tatsächlich intelligent genug, um die Implementierung des zugrunde liegenden Typs zu verwenden, und da dies Intein NumFehler ist , wird es in diesem Fall nicht fehlschlagen.

Wenn für den Fall, dass das Flag aktiviert ist, nichts gedruckt wird, beträgt das Ersetzen mainder folgenden Werte 109 Byte :

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

PostfixOperators, 63 Bytes

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

Probieren Sie es online (ohne Erweiterung)

Probieren Sie es online (mit Erweiterung)

Dies ist eine gekürzte Version eines von mir geschriebenen Hugs / GHC-Polyglots . In diesem Beitrag finden Sie eine Erklärung. Dank @ ØrjanJohansen für die Realisierung, dass ich idanstelle eines benutzerdefinierten Operators vier Bytes einsparen konnte.

DeriveAnyClass, 104 Byte

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

Probieren Sie es online (ohne Erweiterung)

Probieren Sie es online (mit Erweiterung)

Benötigt auch GeneralizedNewtypeDeriving.

StrictData, 97 Bytes

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

Probieren Sie es online aus (keine strengen Daten)

Online testen (strenge Daten)

Benötigt auch DeriveGeneric.

UnicodeSyntax, 33 Byte

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

Probieren Sie es online!

TemplateHaskell, 140 91 Bytes

Nur mit kleinen Modifikationen von Mauke kopiert . Ich weiß nicht, was los ist.

-49 Bytes dank Ørjan Johansen.

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

Probieren Sie es online!

MonomorphismRestriction, 31 29 Bytes

Bearbeiten:

• -2 Bytes mit einer Verbesserung von H.PWiz

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

-XMonomorphismRestriction druckt 0. -XNoMonomorphismRestriction druckt 18446744073709551616.

• Mit dieser Einschränkung müssen die beiden Verwendungen von fdenselben Typ haben, sodass das Programm 2^2^6 = 2^64als 64-Bit-Version Int(auf 64-Bit-Plattformen) gedruckt wird , die überläuft 0.
• Ohne Einschränkung wird das Programm 2^64als Bignum gedruckt Integer.

ScopedTypeVariables, 119 97 Bytes

Nur mit kleinen Modifikationen von Mauke kopiert .

Derzeit gibt es zwei weitere Antworten für ScopedTypeVariables: 113 Bytes von Csongor Kiss und 37 Bytes von dfeuer . Diese Übermittlung unterscheidet sich darin, dass keine anderen Haskell-Erweiterungen erforderlich sind.

-22 Bytes dank Ø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)

Probieren Sie es online!