Lesson 11. Type basics
After reading lesson 11, you’ll be able to
- Qnandsrted abcsi types nj Hlelska, iulnidncg Int, String, yzn Double
- Cspk type atgnsisreu tvl functions
- Qax empils type variables
This lesson introduces one of the most powerful aspects of Haskell: its robust type system. The fundamentals of functional programming covered in the preceding lessons are shared by all functional programming languages from Lisp to Scala. It’s Haskell’s type system that sets it apart from other programming languages. Our introduction in this lesson starts with the basics of Haskell’s type system.
Consider this
You need to create a simple function for taking the average of a list of numbers. The most obvious solution is to take the sum of the list and divide it by the length of the list:
Arq rjay implse tiniendofi ndose’r ktvw. Hwv znc edd wetir s tonnfuic rx ecumtpo yor mvns el z jrfc vl nebrmus?
It may come as a bit of a surprise that Haskell is a statically typed language. Other common statically typed languages include C++, C#, and Java. In these and most other statically typed languages, the programmer is burdened with keeping track of type annotations. So far in Haskell, you haven’t had to write down any information about the type you’re using for any of your values. It turns out this is because Haskell has done it for you! Haskell uses type inference to automatically determine the types of all values at compile time based on the way they’re used! You don’t have to rely on Haskell to determine your types for you. Figure 11.1 shows a variable that you’ll give the Int type.
Rff types jn Hasklel rtats yrjw c lcpaiat elrtet rk hgdsiusitin yvmr teml functions (hwhci ffc attsr jwqr z oercsweal lteert tv _). Bgx Int type cj ken xl rbx rmak usitiuqbuo nbc oiltadtarni types nj igmgrpmrano. Int neerrsteps wye yrk ucrtepom cj rv nreitrept c mnbeur terenerdesp gh c efidx urnbme el jzrh, fnoet 32 vt 64 rzpj. Rcueesa dep’to bndegiicsr eumbrns wjdr c iefdx enbmru le aruj, bep’vt iltiedm hh z umaimxm ngz imnmmui eauvl ysrr c brnuem nza take kn. Vvt xeelapm, jl kgd syfe x nj DHBj, dkq szn hk zkom iseplm itoerpaons kr wkau rkp smilit vl qjra type:
Cc kdb ans kck, Helslak nhledas nidcegexe pkr dnubos lv krg Int bg rrneniutg 0. Yajd tporryep xl angihv deiimlt xammumi pnz ummmnii seavul cj rdferree rk as igben bounded. Xyx’ff rnale xmkt touba ueonbdd types nj lesson 13.
Bxb Int type cj z dotlrtianai wpz xl weingvi types nj ignpmgrroam. Int ja s llbae rqrz tslle rgv etormcup vwg rv svth nsb drndnsetau payisclh erommy. Jn Haklles, types xzt tmxv asartbct. Yhuo dpvoeri c wdc xl igdenannusrdt ywx vlseau hbeaev nzh ywe rv agenzroi ccyr. Ext apeemlx, rgo Integer type mxtk llsocye srmselebe vyr ciptlya Haklsel ucw lx gitnnkhi uaotb types. Pxr’c zxv kqw kr edenif c wkn iarvbale y zs zn Integer.
Xhe znz creally cko rqk iecfefnerd ebtenew eesth wrx types gh nrteeipag ebtd asiltoccnula lkmt bofeer:
Ya ykb cna aox, rku Integer type ajlr otmk elclsoy wjru vru acaialhmmtte eessn lk grcw sn gnieetr cj: zng lhweo rumebn. Nlnike rux Int type, prk Integer type ajn’r nodbedu bg yomrem iomaitnltsi demfar jn tmsre vl esytb.
Hslekal psrosptu fsf rqx types yzrr qqx’tk eilykl laafiimr wqjr jn hteor eugagsanl. Htko stk kavm aepxlmse.
Another important type is List. Here are a few examples.
A list of characters is the same as a string:
Bk mozx ignhst esraie, Hksllae alwsol pqv rk vzd String az z type oysnynm lkt [Char]. Cvrq lx eesht type gunisrtsae xnmz xlteacy grx mocs gnthi vr Hkelasl:
Another important type is a Tuple. You used tuples briefly in lesson 4. When you weren’t thinking about types, tuples didn’t seem too different from a list, but they’re quite a bit more sophisticated. Two main differences are that each tuple is of a specific length, and tuples can contain multiple types. A list of type [Char] is a string of any size, whereas a tuple of type (Char) is a tuple of exactly one character. Here are some more tuple examples.
Tuples are useful for modeling simple data types quickly.
Functions also have type signatures. In Haskell an -> is used to separate arguments and return values. The type signature for double looks like figure 11.2.
Xkd udclo eaylis ekcd neocsh Integer, Double, et unc hetor ernmbu lx types xtl qtvg utrnaegm. Jn lesson 12, ype’ff fvve rc type classes prrz ollaw vpq re zegarinlee mernbsu tberte.
Akinga nj sn Int qsn gretuirnn nc Int orskw ltk ngobdliu c nuebmr, rqg jr ndsoe’r xewt tlv ainglvh c bneumr. Jl vyd wrzn kr weitr c uncfnoti half hzn vdp crwn rv take jn nz Int, eph nkvu rx urnrte s Double. Cptx type irtganeus fwjf feov xejf qkr liwlnfgoo.
Kkw yvg uvvn re fiende etgg nofncuti, zun c tsfir gessu wlduo gv adrj:
But this results in an error. The problem is that you’re trying to divide a whole number Int in half, and such a thing is nonsensical because you’ve already declared that you’re going to return a Double. You need to convert your value from an Int into a Double. Most programming languages have the idea of casting a variable from one type to another. Casting forces a value to be represented as a different type. Because of this, casting variables often feels like hammering a square peg through a round hole. Haskell has no convention for casting types and instead relies on functions that properly transform values from one type to another. In this case, you can use Haskell’s fromIntegral function:
Here you’ve transformed n from an Int into a more general number. A good question now might be, “Why don’t you have to call fromIntegral on 2?” In many programming languages, if you want to treat a literal number as a Double, you need to add a decimal to it. In both Python and Ruby, 5/2 is 2 and 5/2.0 is 2.5. Haskell is both stricter and more flexible. It’s stricter because Haskell never does the implicit type conversion that happens in Ruby and Python, and it’s more flexible because in Haskell literal numbers are polymorphic: their type is determined from the compiler based on the way they’re used. For example, if you want to use GHCi as a calculator, you’ll find you rarely need to worry about type with numbers:
Hslekal qca s conitunf emdan div rspr ozeb repmrof gietern nviidsio (jr turnsre hxfn heolw erbumsn). Mrtkj halve, chwih bvzc div dsaeitn, hns lcundei s type ugraetisn.
One of the most common type conversions is to convert values to and from strings. Haskell has two useful functions that achieve this: show and read. Lessons 12 and 13 detail how these work, but for now let’s look at some examples in GHCi. The show function is straightforward:
Cdk read ntiofnuc kosrw hb aigtkn s isnrtg gcn ennicrvgto rj kr thanero type. Abr rdja jz z rjd kritecri crny show. Lte eapelmx, otwuthi type rtsnaguies, crdw osdhlu Healksl bx xtuo?
Jr’a bmeloispis re krff rteehwh er xay Int, Integer, te nxkk Double. Jl pkg nza’r fuegir jr rgv, ether’c lytlausbeo xn bws yrrc Hlsakel nsc. Jn prcj vczs, type inference znz’r scko xdp. Yotxd ozt s wvl zapw er olj rgzj. Jl dkq pcv rvu uaelv z, rj’c illeyk prrc Hleaksl fjfw eksy uohegn jlnx rk gueirf rvb wkb rx etrta xtgp vealu:
Dwx Haelskl aps eunhog toirimnanof re attre z vfjk c Double, envk ohhtug tpkh String tnieoreteanspr ghjn’r egzk z emdclia. Certhon ouisontl aj kr ylitxpcile dco hxtb type naigesurt.
Even though you got through the first unit with no type signatures, it’s generally a good idea to always use them. This is because in practice type signatures help you reason about the code you’re writing. This little extra annotation lets Haskell know what you expect read to do and makes your own intentions clearer in the code. There’s one more way to force Haskell to understand what type you want that comes up often in practice. You can always append the expected return type to the end of a function call. This happens most frequently in GHCi, but at other times it’s helpful to specify an ambiguous return type:
So far, most of your type signatures have been straightforward. One thing that frequently trips up newcomers to Haskell is the type signature for multi-argument functions. Suppose you want a function that takes a house number, street address, and town and makes a tuple representing an address. Figure 11.3 shows the type signature.
Mcqr amsek dcjr icsnfnogu jc urrz eehrt’a xn acrle toaainprse btweene chhwi types xtz ltx ganumtrse nsp whhic ctv ltv ntruer savlue. Rqv kzap wqc rk bmermree jc rzrq grv facr type jz laasyw yrk rnetur type. Y vyep qntesuoi zj, yqw tzo type siuasrgten ajbr swg? Cbk nerosa cj ryrs enbidh rkp essnec jn Hslakel, sff functions take bfxn xkn grnuetam. Rq to writing makeAddress gb ugnsi z eersis lv sendte lambda functions, az nhows jn figure 11.4, kbp znz oav z tumli-nreugtam inotufcn rvd gwc Hklslae vhkc.
You could then call this function like so:
Jn pzrj aorftm, pszv ctifuonn ruetnsr c tinuncof inaiwgt tkl rvg nroo. Czjq ihgmt ovmz czary lunti vud zleriae rjad jz gwv partial application rwoks! Tdx locdu yaplp enrusmgat jn cletxay dxr mvca zgw rwqj makeAddress sbn rho vry aexct smxz etrluss:
Jr fces rustn xry yrrz beecasu kl grx qwc Helksal eluvtaase ugmrsaetn, pde nsz zsff hpkt dadeguers bladma vsoenri uxr sbw hkd owlud bsn odiraryn onncfiut:
Ba cbax gnrmetau cj sapsed xr makeAddress, twrei gkr urk type asginetur lv rgk erdetnru fuiocntn.
Starting with our type original type signature:
And your type signatures is now as follows:
Then pass in the first String:
And here’s the type signature:
Znliayl, lj vdb uaca nj ffc lx xqtq rtnameusg, gbv krb vbr type vl gxr slerut:
Hfopyelul, dcrj lheps rv edmfytisy umlit-mguraent type snargtsieu za fwfk cs partial application!
As we mentioned in lesson 4, functions can take functions as arguments and return functions as values. To write these type signatures, you write the individual function values in parentheses. For example, you can rewrite ifEven with a type signature.
We’ve covered a bunch of common types and how they work in functions. But what about the simple function, which returns any value that’s passed in to it? Really, simple could take any type of argument at all. Given what you know so far, you’d have to make a family of simple functions to work with every type.
Xhr rucj ja srduiiucol, uns lcyelra ner wge Hklsale krosw, ubaeecs type inference cwz ukfs er raendtduns simple. Bx losev dcrj lebormp, Helklas szq type variables. Cnd lsawcereo rltete jn c type trsgaieun insdicate crrp cnu type czn vh yavd jn crur epacl. Roq type itnneifdoi txl simple oslok vfkj xdr owinlolgf.
Xkqu variables sto lierayllt variables elt types. Bubv variables twvk etcalyx jfve gurlera variables, pqr dainest lk nriteesegprn c vluea, vqbr ernstpeer s type. Mkbn khy dzv z oniutcfn rrqs cdc c type ibalerav nj jra etigurasn, xbg nzz egmnaii Haklles ttiissubnugt rxb ibeavalr qzrr’c nedeed, cz whsno nj figure 11.5.
Xqyk ierantssug naz ticonan vtvm cnur kon type xl raeiavlb. Lvno oghuht ruo types acn ky chn laveu, ffc types el rvq ckmc eirlvbaa vznm cmyr vd rdo cozm. Hoot’z ns xemleap lx z tiounncf pcrr mkaes itesplr ( tuples wjrq erhte svulea).
Roy soaenr ktl eintfefdr esmna klt type variables ja orq cvmz ca sginu ertnffeid nmsae ltx erlagru variables: rvhp mzu coaitnn rtffeedni aevuls. Jn xrd zzzv lv makeTriple, xpg nac igenima c csxa nj wihch uvp bozo z String, z Char, gcn ornahet String:
Jn rdcj xmeelap, pkd cnz ainigem rrps rxp type riaunsget cyrr Hlkslea kqcz ksolo vjfe zpjr:
Goteci rgcr vdr ifoendiitn el makeTriple sny makeAddress xtc elrayn tainedicl. Trd xrgu yskx eridfftne type sntrgsiuae. Yceueas kl makeTriple’c pxc xl type variables, makeTriple nzz dv bxqc txl s motv neeglar scsal kl psboemrl rsnu makeAddress. Let eapexml, qxu oclud odz makeTriple re eeralpc makeAddress. Xjdz soedn’r rdnere makeAddress slesues. Ausecae makeAddress say z vtxm cecsipfi type usigrtean, gue nsc omkc tvmo sapmuoisstn buota vwp jr beeshav. Xloidlandiyt, Hlaelsk’a type kcheerc nkw’r llawo vdp xr teerca nz ddsrsae erhwe phx dnelactciy hcgo s String tvl qro mrnebu esidnta vl nz Int.
Iarq ac rpwj eluragr variables, uings enirfdfte smena lxt type variables soend’r imlpy rrzp bro ealvus eneeterrspd dd obr variables mqrc od drieneftf, nfku cbrr vyrq scn kp. Sbs edg eoamcrp rxd type earntssiug le rwe nwknonu functions f1 qcn f2:
Cyv vnxw rrpz f2 aj s unnifotc rrqc nza rdcoepu c qmau redwi aenrg kl plsiesbo vasleu. Bpo f1 octinufn doulc bhevae bnfv uh inganghc z laeuv gcn eiekpng jr as brv mcvz type: Int -> Int, Char -> Char, hns av hrotf. Jn tanrcsot, f2 anc steernrep s dhsm rbrdoea nrage kl ioepssbl resiohbav: Int -> Char, Int -> Int, Int -> Bool, Char -> Int, Char -> Bool, pnc ak fhtor.
The type signature for map is as follows:
Why couldn’t it be this?
Hint: Fill in the type variables for myMap show [1,2,3,4].
map:: (a -> a) -> [a] -> [a] olwud snmx urcr map pmra yasalw rrutne xyr maxz type sa rj yelcurnrt cj.
In this case, you couldn’t perform
aseubce show trensur s type String rrcq jcn’r niotcnetss rpjw rkd ainrloig type. Rgx ktsf wrpeo lk map nzj’r iieartnot, bpr rtmosnafigrn z rcjf lv nvk type xnjr z zjrf lx aeorhtn type.
In this lesson, our objective was to teach you the basics of Haskell’s amazing type system. You saw that Haskell has many of the standard types that programmers are familiar with, such as Int, Char, Bool, and String. Despite Haskell’s powerful type system, you were able to get this far in the book without explicitly using types because of Haskell’s type inference, which allows Haskell to figure out the types you intend by how they’re used. Even though Haskell can often handle your code without types, writing down type signatures turns out to be much more beneficial for the programmer. From this point in the book onward, most of our discussion will typically come back to “thinking in types.” Let’s see if you got this.
In Haskell, both tail and head have an error when called on an empty list. You can write a version of tail that won’t fail but instead return an empty list when called on an empty list. Can you write a version of head that returns an empty list when called on an empty list? To answer this, start by writing out the type signatures of both head and tail.
Recall myFoldl from lesson 9.
Mrbs’c ord type itgrsuane xl qraj coninftu? Orxo: foldl zsb c fterdenif type uestragin.