[Haskell-cafe] Function to cast types
Roel van Dijk
vandijk.roel at gmail.com
Sun Mar 22 09:53:15 EDT 2009
> I'm new to haskell, I'm wondering how can you write a function that will do
> the following:
> fromIntToString :: Int -> String
> this is a cast function to cast an Int to a String.
I'll assume that by a cast you mean a conversion from one type to
another where no information is lost.
-- Let's assume that we can represent every Int using a String
intToString :: Int -> String
intToString n = ...
-- Not every member of String can be interpreted as an Int, for
-- example "aabc" is nonsense when viewed as an Int.
stringToInt :: String -> Maybe Int
stringToInt s = ...
-- This property should hold for every Int. It states that given some
-- Int called n we can convert it to a string and back without losing
prop_intString :: Int -> Bool
prop_intString n = maybe False (== n) . stringToInt . intToString $ n
Using such a property can be really useful to test your implementation
of intToString and stringToInt.
> I know such function
> exist, however let's assume it didn't exist. How would I write such
> function? Cause I have no idea, because there are infinity possibilities if
> I do it like:
> fromIntToString x | x == 1 = "1"
> | x == 2 = "2"
> -- And so on...
It might be useful to first write this function first:
intToDigits :: Int -> [Int]
intToDigits n = ...
It should convert an integer to a list of its digits (using normal base 10):
intToDigits 123 == [1, 2, 3]
Then you can write a function which takes such a list and converts it
to a string. (Hint: use 'map' in combination with a function of type
'Int -> Char')
You have to take extra care if you also want to support negative numbers.
> I've also thinked about defining the defining the data types Int and String
> (I know you cannot redefine them, at least I think so), however I've no
You can create your own datatypes which behave roughly the same as Int
and String. You will never be able to create something which behaves
exactly as a String because it is treated a bit special (it has its
data MyInt = ...
data MyString = ...
instance Num MyInt where ...
instance IsString MyString where ...
By creating an instance of Num for your own type MyInt you'll be able
to use the familiar operators +, - etc... If you want all the
functionality that normal Ints have for your own type you'll also need
instances of Bounded, Enum, Eq, Integral, Num, Ord, Read, Real, Show
and Ix. I might have forgotten a few :-) Some of those can be
automatically derived for you. (data MyInt = ... deriving Show, for
I hope some of this is useful to you.
More information about the Haskell-Cafe