Son zamanlarda, NegativeLiteralsuzantının devreye girip girmediğini tespit edebilecek bir Haskell programı yazma zevkim oldu. Aşağıdakilerle geldim:

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

Çevrimiçi deneyin!

Bu Truenormal ve Falsebaşka şekilde yazdırılır .

Şimdi bunu yaparken çok eğlendim, hepinize meydan okuyorum. Başka hangi Haskell dil uzantılarını çözebilirsiniz?

kurallar

Belirli bir dil uzantısını kırmak için, dil uzantısına sahip olan ve olmayan (uyarılar iyidir) derleyen ve dil uzantısıyla çalıştırıldığında kapatılan iki farklı hata değeri veren ve kapatılan (bir Noönek ekleyerek ) bir Haskell programı yazmalısınız . dil uzantısı). Bu şekilde yukarıdaki kod kısaca kısaltılmış olabilir:

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

hangi baskılar 1ve -1.

Bir uzantıyı kırmak için kullandığınız herhangi bir yöntem bu uzantıya özgü olmalıdır. Hangi derleyici bayraklarının veya LanguageExtensions'ın etkin olduğunu, bu tür yöntemlere izin verilmiyorsa keyfi olarak tespit etmenin yolları olabilir. -OBayt sayınıza ücretsiz olarak ek dil uzantılarını etkinleştirebilir veya derleyici optimizasyonunu değiştirebilirsiniz .

Dil uzantıları

Bir yoktur herhangi bir dil uzatma kıramazlar Nomeslektaşı (örneğin Haskell98, Haskell2010, Unsafe, Trustworthy, Safe), bu yukarıda özetlenen şartlar altında düşmez çünkü. Diğer her dil uzantısı adil bir oyundur.

puanlama

İlk kırılan her dil eklentisi için bir puan ve en kısa (bayt cinsinden ölçülen) çatlağa sahip olduğunuz her dil uzantısı için bir ek puan alacaksınız. İkinci noktaya göre, bağlar daha önceki başvuruların lehine kopacak. Yüksek puan daha iyi

İlk gönderim için puan kazanamayacaksınız NegativeLiteralsya da QuasiQuotesben zaten onları kırdım ve gönderinin gövdesine ekledim. Bununla birlikte, bunların her birinin en kısa çatlağı için bir puan kazanabileceksiniz. İşte benim çatlakQuasiQuotes

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

Çevrimiçi deneyin!

MagicHash, 30 bayt

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

-XMagicHash 1, -XNoMagicHash çıkışları 2 çıkışları

MagicHash değişken isimlerinin a ile sonlandırılmasını sağlar #. Bu nedenle uzantılı, bu iki işlev tanımlar y#ve x#her hangi bir değer alır ve bir sabit dönüş 2ya da 1. x#x1 döndürür (çünkü x#uygulanır 1)

Bu, uzantı olmadan, #iki argüman alan ve dönen bir işlevi tanımlar 2. x#a=1Ulaşıldığında geçmez bir kalıptır. Daha sonra x#xise 1#12 döndüren.

CPP, 33 20 bayt

main=print$0-- \
 +1

Baskılar 0ile -XCPPve 1ile -XNoCPP.

İle -XCPP, bir eğik \bir satır önce yeni satır kaldırır, böylece kod olur main=print$0-- +1ve tek 0olarak basılır+1 yorumun bir parçası olduğu .

Bayrak olmadan yorum yoksayılır ve ikinci satır bir önceki satırın parçası olarak ayrıştırılır, çünkü girintilidir.

İle önceki yaklaşım #define

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

Ayrıca yazdırır 0ile -XCPPve 1ile -XNoCPP.

NumDecimals, 14 bayt

main=print 1e1

-XNumDecimals yazdırır 10. -XNoNumDecimals yazdırır 10.0.

BinaryLiterals, 57 bayt

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

-XBinaryLiterals , tek bir yeni satır basar. -XNoBinaryLiterals a 1.

Bunu yapmanın daha iyi bir yolu olduğundan eminim. Bir tane bulursanız, lütfen gönderin.

MonomorfizmRestriction + 7 others, 107 bayt

Bu -XTemplateHaskellher zaman bayrak gerektiren TH kullanır .

T.hs Dosyası, 81 + 4 bayt

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

Ana, 22 bayt

import T
main=print $t

Bayrak derlenmesi MonomorphismRestriction türünü zorlar piçin Integer -> Integer -> Integerve böylece aşağıdaki çıktıyı üretir:

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

Bayrakla derlemek NoMonomorphismRestrictionp , en genel olarak, yani türünü bırakır . Num a => a->a->a- şöyle bir şey üretmek ( VarTisimleri kısaltmak 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"

Onları çevrimiçi deneyin!

Alternatifler

Yukarıdaki kod basitçe tipini pbastırdığından, bu bir şekilde Haskell'in tiplerini nasıl etkilediğini etkileyen tüm bayraklarla yapılabilir. Ben sadece bayrak ve fonksiyonu değiştirecek olanla pve gerekirse ilave bayraklar belirleyeceğim -XTemplateHaskell:

Aşırı Yüklenenler, 106 bayt

Ek ihtiyaçlar -XNoMonomorphismRestriction:

p=[]

Ya p :: [a]ya p :: IsList l => l, çevrimiçi olarak deneyin!

Aşırı YüklenmişStrings, 106 bayt

Ek ihtiyaçlar -XNoMonomorphismRestriction:

p=""

Ya p :: Stringya p :: IsString s => s, çevrimiçi olarak deneyin!

PolyKinds, 112 bayt

Bunun nedeni tamamen @CsongorKiss:

data P a=P 

Ya P :: P aya P :: forall k (a :: k). P a, çevrimiçi olarak deneyin!

MonadComprehensions, 114 bayt

p x=[i|i<-x]

Ya p :: [a] -> [a]ya p :: Monad m => m a -> m a, çevrimiçi olarak deneyin!

NamedWildCards, 114 bayt

Bu, @Likonik tarafından bulundu, ayrıca şunları gerektirir -XPartialTypeSignatures:

p=id::_a->_a

Her ikisi de save türüne sahip ( p :: a -> a) ancak GHC değişkenler için farklı adlar üretiyor, çevrimiçi olarak dene!

Uygulamalı Yapılacaklar, 120 bayt

p x=do i<-x;pure i

Ya p :: Monad m => m a -> m aya p :: Functor f => f a -> f a, çevrimiçi olarak deneyin!

Aşırı Yüklenmiş Etiketler, 120 bayt

Bunun için ek bayrağa ihtiyaç var -XFlexibleContexts:

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

Ya olarak tipleri p :: a -> b -> bveya p :: IsLabel "id" (a->b) => a -> b, çevrimiçi olarak deneyin!

CPP, 27 25

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

Çevrimiçi deneyin!

Baskılar ()için -XCPPve 1için-XNoCPP

Önceki versiyon:

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

Çevrimiçi deneyin!

Baskılar [1]ile -XCPPve [1,2]aksi.

Krediler: Bu Laikoni'nin cevabından ilham alıyor, ancak bunun yerine #definesadece C yorumlarını kullanıyor.

ScopedTypeVariables, 162 113 bayt

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

-XScopedTypeVariables yazdırır ""(boş), -XNoScopedTypeVariables yazdırır "[()]".

Düzenleme: yorumlardaki yararlı öneriler sayesinde güncellenmiş çözüm

MonoLocalBinds, GADT'ler veya TypeFamilies, 36 32 bayt

DÜZENLE:

• -4 bytes: Bunun bir versiyonu büyük polyglot zincirine dahil edildi. Bütün bildirimleri üst düzeye koyarak beni şaşırtan stasoid tarafından eklendi. Görünüşe göre bu kısıtlamayı tetiklemek gerçek yerel bağlamalar gerektirmez .

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

• İle hiçbir uzantıları , bu program yazdırır (1.0,1).

• -XMonoLocalBinds bayraklarından herhangi biriyle , -XGADTs veya -XTypeFamilies basar (1.0,1.0).

• Bu MonoLocalBindsuzantı, GADT'ler ve yazım aileleri tarafından tetiklenen bazı sezgisel türden çıkarımları önlemek için mevcuttur. Dolayısıyla, bu eklenti iki kişi tarafından otomatik olarak açılır.

• O ise yine açık bir şekilde belirtilen kapatmak mümkündür -XNoMonoLocalBinds, bu hüner değil mi varsayar.

• Daha iyi bilinen kuzeni gibi, monomorfizm kısıtlaması gibi, MonoLocalBindsbazı değerlerin ( ya da gibi yerel bağlarda letya da wherebu nedenle görünüşte en üst düzeyde de görülebilen adın ) polimorfik olmasını engelleyerek çalışır. Daha akılcı bir çıkarım için yaratılsa da, tetiklendiği zaman kurallar MR'dan daha kıllıdır.

• Herhangi bir uzantısı olmadan, yukarıdaki program infers tipi f :: Num a => a -> asağlayan f pibir varsayılan olarak Doubleve f 0bir karşı Integer.

• Eklentilerde f :: Double -> Double, çıkarılan tür olur ve f 0aynı zamanda geri dönmek zorunda kalır Double.
• a=0Teknik kuralları tetiklemek için ayrı değişkene ihtiyaç vardır: amonomorfizm kısıtlaması tarafından vurulur ve abunun serbest bir değişkenidir ; bu f, fbağlayıcı grubun tamamen genelleştirilmediği , yani kapalıf olmadığı ve dolayısıyla polimorfik olmadığı anlamına gelir .

Aşırı YüklenmişStrings, 65 48 32 bayt

RebindableSyntax'ın avantajlarından yararlanarak, herhangi bir dizgenin değişmesini sağlamak için fromString'in kendi versiyonunu kullanın "y".

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

İle derlenmeli -XRebindableSyntax -XImplicitPrelude .

-XOverloadedStringsParmak izi olmadan ""; baskı ile"y".

Ayrıca, sadece şimdi bana aynı tekniğin (örn., Aşırı Yüklenenler Listeleri) çalıştığını söyledi:

Aşırı Yüklenenler, 27 bayt

main=print[0]
fromListN=(:)

İle derlenmeli -XRebindableSyntax -XImplicitPrelude .

-XOverloadedListsParmak izi olmadan [0]; baskılar [1,0].

BangPatterns, 32 bayt

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

-XBangPatterns yazdırırken 1, -XNoBangPatterns yazdırır 0.

Bu, BangPatterns bayrağının WHNF için !değerlendirmeyi zorlamak için desenleri eklemeye izin vermesini sağlar , bu durumda 9!1en üst düzey tanımı kullanacaktır (!)=seq. Bayrak etkin değilse f!_, yeni bir operatör tanımlar (!)ve üst seviye tanımını gölgelendirir.

Uygulamalı Yapılacaklar, 104 bayt

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

Çevrimiçi deneyin!

İle ApplicativeDo, bu baskılar

ZipList {getZipList = [1]}

Onsuz, yazdırır

ZipList {getZipList = []}

ZipListtemel kütüphanelerdeki bir örneği olan Applicativeancak olmadığından az sayıdaki türden biridir Monad. Bir yerde gizlenen daha kısa alternatifler olabilir.

Katı, 87 84 82 bayt

^{Dfeuer sayesinde -5 bayt !}

BlockArgumentsParenleri saklamakla daha az olabilir \_->print 1:

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

Bu Koşu -XStrict bir yazdırır 1ile çalışan oysa -XNoStrict bir yazdırır 0. Bu, Haskell'in varsayılan olarak tembel olduğunu ve değerlendirmenin gerekli olmadığını, error""çünkü sonucun 0ilk argümanıyla eşleştiği zaman olacağını bildiği için değerlendirmek zorunda değildir .(!) bu davranışı o bayrakla değiştirebilir - çalışma zamanını her iki argümanı da değerlendirmek için zorlar.

Bir durumda hiçbir şeyi yazdırmama izin verilmezse, bunu ana bayt yerine 75 bayta indirebiliriz (ayrıca bazı baytlar dfeuer'in yanında ):

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

StrictData, 106 99 93 bayt

^{Dfeuer sayesinde -15 bayt !}

Bu temelde aynısını yapar ancak bunun yerine veri alanlarıyla çalışır:

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

Baskılar 1ile -XStrictData bayrağı ve 0birlikte -XNoStrictData .

Bir durumda hiçbir şeyi yazdırmama izin verilmezse , ana kartı değiştirerek (bayt tarafından 19 byte ) 86 bayta indirebiliriz :

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

Not: Tüm çözümler TypeApplicationsset gerektirir .

Uygulamalı Yapılacaklar, 146 bayt

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 etkinleştirildiğinde 1, aksi takdirde 0 yazdırır

Çevrimiçi deneyin!

BinaryLiterals, 31 24 bayt

Düzenle:

• -7 bayt: H.PWiz, tek bir b12değişken kullanarak daha fazla düzenlemeyi önerdi .

İşlev örneğini engelleyerek H.PWiz'in yöntemine ayar yapıldı .

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

• İle -XNoBinaryLiterals , 0b12olarak lexes 0 b120 + 1 = baskı, 1.
• İle -XBinaryLiterals , 0b12olarak lexes 0b1 21 + 2 = baskı, 3.

ExtendedDefaultRules, 54 53 bayt

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

Baskılar ()ile -XExtendedDefaultRulesve 0ile -XNoExtendedDefaultRules.

Bu bayrak varsayılan olarak GHCi’de etkinleştirilir, ancak yakın zamanda benim için karışıklığa neden olan GHC’de etkinleştirilmez , ancak BMO hızlı bir şekilde yardımcı olabilir.

Yukarıdaki kod, GHCi'de varsayılan ayar türünün açıklandığı GHC Kullanıcı Kılavuzu'ndaki bir örneğin golf versiyonudur .

Ørjan Johansen sayesinde -1 bayt !

RebindableSyntax , 25 bayt

Henüz burada hatırlamadığım kolay bir tane olduğunu fark ettiğimde , GHC'nin Uzantılarıyla İlgili Yayınlanan Kılavuzu okuyordum .

main|negate<-id=print$ -1

• İle -XNoRebindableSyntax , yazdırır -1.
• İle -XRebindableSyntax , yazdırır 1.

Ayrıca -XImplicitPreludeveya alternatif import Preludeolarak kodun kendisinde de gerekir .

• -XRebindableSyntax Haskell'in bazı sözdizimsel şekerlerinin davranışını yeniden tanımlamayı mümkün kılmak için değiştiriyor.
• -1sözdizimsel şeker negate 1.
• Normal olarak, bu negateise Prelude.negate, ancak uzantısı ile "hangisi olduğunu negateolarak tanımlanır, kullanım noktasında dar olduğundan," id.
• Uzantı, Preludemodülün yerine geçecek şekilde kullanılmak üzere tasarlandığından , bunun normal olarak içe aktarılmasını otomatik olarak devre dışı bırakır, ancak burada başka Preludeişlevlere (benzeri print) ihtiyaç vardır, bu nedenle yeniden etkinleştirilir -XImplicitPrelude.

Katı, 52 bayt

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

-XStrict

-XNoStrict

İle ekstra zaman -XStrictbasar ().

İki bayt için @Sriotchilism O'Zaic'e teşekkürler.

StrictData, 58 bayt

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

(Bağlantılar biraz modası geçmiş; düzeltilecek.)

-XNoStrictData

-XStrictData

gerektirir MagicHash ( GHC.Extsyerine içe aktarmamıza izin vermek için Unsafe.Coerce) ve-O (kesinlikle zorunlu, küçük sıkı alanların açılmasını sağlamak için gereklidir).

İle -XStrictData , Aksi takdirde 3. basar, önceden tahsis edilmiş bir kopyasına (muhtemelen etiketli) ibrenin tamsayı değerini yazar 3::Integermuhtemelen 3 olamaz.

açıklama

Tip varsayılanlarına bağlı olarak küçük bir genişleme ile anlaşılması biraz daha kolay olacaktır. İmzalarla eklemeyi bırakabiliriz.

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

eşdeğer,

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

Neden hiç yazdırmıyor 3? Bu şaşırtıcı görünüyor! Peki, küçükInteger değerler çok benziyorInt (s katı veri ile) Ds gibi temsil edilen s'ye benzer. Tamsayının küçük veya büyük pozitif / negatif olduğunu gösteren etiketi görmezden geliriz.

Neden uzantı olmadan 3 yazdıramıyor? Herhangi bir bellek düzeni nedenini bir kenara bırakmak gerekirse, düşük bitli (32 bit için en düşük 2, 64 bit için 3 en düşük) 3 veri işaretçisinin üçüncü yapıcıdan oluşturulan bir değeri temsil etmesi gerekir. Bu durumda, negatif bir tamsayı gerektirir .

UnboxedTuples, 52 bayt

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

Gerektirir -XTemplateHaskell. Baskılar ConE GHC.Prim.(##)ile -XUnboxedTuples ve UnboundVarE ##birlikte -XNoUnboxedTuples .

Aşırı Yüklenenler, 76 bayt

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

-XOverloadedLists ile yazdırır [()]. -XNoOverloadedLists ile yazdırır[]

Bu ek bayrakları gerektirir: -XFlexibleInstances,-XIncoherentInstances

HexFloatLiterals , 49 25 bayt

Ørjan Johansen sayesinde -24 bayt.

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

Baskılar 0.0ile -XHexFloatLiteralsve 0ile -XNoHexFloatLiterals.

HexFloatLiterals ghc 8.4.1'e eklendiğinden TIO bağlantısı yok, ancak TIO'nun ghc 8.2.2'si var.

ScopedTypeVariables, 37 bayt

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

Bu aynı zamanda gerektirir UnicodeSyntax, PartialTypeSignatures, GADTs, ve ExplicitForAll.

Çevrimiçi olarak deneyin (uzantısız)

Çevrimiçi olarak deneyin (uzantıyla birlikte)

açıklama

Kısmi tür imzaları sadece baytları kurtarmak içindir. Onları şöyle doldururuz:

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

Kapsamlı tip değişken ile, abir türü 1kısıtlanır olması atipinde mainkendisi olacak şekilde tahdit edilmiş, Float. Kapsamlı tür değişkenleri olmadan, yazılacak 1varsayılanlar Integer. yana FloatveInteger değerler farklı şekilde gösterilebilir, onları ayırt edebilir.

Bir kuyruklu 19 bayt için @ ØrjanJohansen'e teşekkürler! ShowFarklı sayısal türlerin örnekleri arasındaki farkın, aritmetiklerindeki farklılıklardan daha iyi kullanılmasının çok daha iyi olduğunu fark etti . Ayrıca, main“sözdizimsel olarak belirsiz” türünden ayrılmanın tamam olduğunu fark etti; çünkü kısıtlama gerçekten de onu karartıyor. Yerel işlevden kurtulmak, ayrıca mainbeş bayttan daha fazla tasarruf etmek için tür imzasını kaldırmak için beni serbest bıraktı .

DeriveAnyClass, 121 113 bayt

^{Bazı baytlar için dfeuer'e teşekkürler !}

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

-XDeriveAnyClass yazdırırken 1, -XNoDeriveAnyClass yazdırır M 0.

Bu, uyarılardan görebileceğiniz gibi, hem DeriveAnyClass hem de GeneralizedNewtypeDeriving etkinleştirildiğinde DeriveAnyClass'ın varsayılan strateji olduğu gerçeğinden faydalanıyor. Bu bayrak, tüm yöntemler için mutlu bir şekilde boş uygulamalar oluşturacaktır, ancak GeneralizedNewtypeDeriving, altta yatan türün uygulamasını kullanmak için yeterince akıllıdır ve bu Intdurumda bir Numbaşarısızlığa uğramayacaktır.

Hiçbir şeyin basılmaması durumunda, bayrak değiştirilerek bayrak main , aşağıdakileri 109 bayt olacaktır :

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

PostfixOperators, 63 bayt

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

Çevrimiçi olarak deneyin (uzantısız)

Çevrimiçi olarak deneyin (uzantıyla birlikte)

Bu bir kesim versiyonu yazdığım bir Hugs / GHC polyglot'un . Açıklama için o yazıya bakınız. idÖzel operatör yerine kullanabileceğim ve dört byte tasarruf sağlayabileceğim için @ ØrjanJohansen'e teşekkürler .

DeriveAnyClass, 104 bayt

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

Çevrimiçi olarak deneyin (uzantısız)

Çevrimiçi olarak deneyin (uzantıyla birlikte)

Ayrıca gerektirir GeneralizedNewtypeDeriving.

StrictData, 97 bayt

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

Çevrimiçi deneyin (kesin veri yok)

Çevrimiçi deneyin (kesin veriler)

Ayrıca gerektirir DeriveGeneric.

UnicodeSyntax, 33 bayt

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

Çevrimiçi deneyin!

TemplateHaskell, 140 91 bayt

Küçük değişikliklerle mauke'den yeni kopyaladım . Neler oluyor bilmiyorum.

Ørjan Johansen sayesinde -49 bayt.

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

Çevrimiçi deneyin!

MonomorfizmRestriction, 31 29 bayt

Düzenle:

• H.PWiz’in geliştirdiği -2 bayt

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

-XMonomorphismRestriction yazdırır 0. -XNoMonomorphismRestriction yazdırır 18446744073709551616.

• Kısıtlama ile, iki kullanım faynı türde olmaya zorlanır, bu nedenle program , taşan 2^2^6 = 2^6464-bit Int(64-bit platformlarda) olarak yazdırılır .0 .
• Kısıtlama olmadan, program 2^64bir bignum olarak yazdırılır Integer.

ScopedTypeVariables, 119 97 bayt

Küçük değişikliklerle mauke'den yeni kopyaladım .

Halen ScopedTypeVariables için iki cevap daha var: 113 byte by Csongor Kiss ve dfeuer tarafından 37 bayt . Bu gönderi, başka Haskell eklentileri gerektirmediğinden farklıdır.

Ørjan Johansen sayesinde -22 bayt.

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

Çevrimiçi deneyin!