Core Types and Literals | CodeSignal Learn

Core Types and Literals | CodeSignal Learn

Binding Values and Type Signatures

Welcome to the second unit of our course! In the previous lesson, we learned how to write our first Haskell program by creating a main block and using putStrLn to display a message on the screen. Any useful program needs to work with data. In Haskell, we do this by binding a piece of data to a name using the equals sign (=). Haskell count = 42 Here, we are storing the number 42 under the name count . However, Haskell is a strictly typed language, which means it likes to know exactly what kind of data a name holds. We provide this information using a type signature . Haskell count :: Int count = 42 The double colon (::) can be read as "has the type of." In this example, we are telling Haskell that count has the type of Int (short for integer), and then we assign it the value 42 . Providing these type signatures makes our code safer and much easier to read.

Number Types: Int, Integer, and Double

Haskell has built-in types for different kinds of numbers. Let us start by looking at the standard whole number, the Int. Haskellcount :: Int count = 42 An Int is used for everyday whole numbers, like counting items or indexing positions. However, Int has a maximum size limit depending on the computer running the code. If you need to store an incredibly large whole number, Haskell provides the Integer type. HaskellbigNumber :: Integer bigNumber = 9000000000000000000 Unlike Int, an Integer is unbounded, meaning it can hold a number as large as your computer's memory can handle. Finally, when you are dealing with fractional numbers or measurements, you will use the Double type. Haskellprice :: Double price = 19.95 The Double type represents numbers with decimal points. By specifying Double, Haskell knows to expect a fractional value rather than a whole number. A quick note on money: although a Double can hold a value like 19.95, real-world money is usually not stored as a Double. Because Double uses binary floating-point, it can introduce tiny rounding errors over time. Production code typically represents currency with integer cents, a fixed-point type, or a dedicated decimal library. We use 19.95 here purely to illustrate a decimal value.

Text and Logic Types: Char, String, and Bool

Sign up

Join the 1M+ learners on CodeSignal

Be a part of our community of 1M+ users who develop and demonstrate their skills on CodeSignal

Beyond numbers, our programs often need to handle text and make logical decisions . To represent a single character, such as a letter or a punctuation mark, we use the Char type. When defining a Char, you must wrap the value in single quotes. Haskell initial :: Char initial = 'H' If you need a sequence of characters, you will use the String type, which you briefly saw in the previous unit. Unlike a Char, a String must be wrapped in double quotes. Haskell greeting :: String greeting = "Welcome to Haskell" Lastly, to handle logical decisions, we use the Bool type (short for Boolean). A Bool can only hold one of two possible values: true or false . In Haskell, these values must always be capitalized. Haskell isReady :: Bool isReady = True

Displaying Values: putStrLn vs. print

In the previous lesson, you learned how to use putStrLn inside your main block's do sequence to print text to the screen. Haskell greeting :: String greeting = "Welcome to Haskell" main :: IO () main = do putStrLn greeting If you run this code, the output will simply be: text Welcome to Haskell Notice that putStrLn prints the String cleanly, without the double quotes. However, putStrLn only works with String values. To display any other core type — like our numbers, booleans, or single characters — we use the print function. Haskell count :: Int count = 42 initial :: Char initial = 'H' main :: IO () main = do print count print initial The output of this code will be: text 42'H' The print function works with any value that Haskell knows how to show (turn into text for display) — this includes numbers, Bool, Char, and even String values. It formats them safely, which is why it adds quotes around text and characters. Notice that when print displays our Char, it includes the single quotes in the output. Because of this, our course convention is to use putStrLn for clean, user-facing text (no quotes) and print for numbers, booleans, characters, and other showable values.

Summary and Next Steps

Let us combine everything we have learned into a complete program. We will build a small "user profile" that defines one value for all six core data types we covered, includes their type signatures, and prints them all correctly inside our main block. Haskell count :: Int count = 42 bigNumber :: Integer bigNumber = 9000000000000000000 price :: Double price = 19.95 isReady :: Bool isReady = True initial :: Char initial = 'H' greeting :: String greeting = "Welcome to Haskell" main :: IO () main = do putStrLn greeting print count print bigNumber print price print isReady print initial Running this complete code will produce the following output: text Welcome to Haskell 429000000000000000000 19.95 True'H' Excellent work! You now know how to explicitly define Haskell's core data types and display them appropriately on the screen. As we move into the upcoming practice exercises, you will get hands-on experience defining these types, writing explicit signatures, and choosing between putStrLn and print to build out your programs. Good luck!