将一种数据类型转换为另一种

Question

I am so familiar with imperative language and their features. So, I wonder how I can convert one data type to another?

ex:
   in c++
           static_cast<>
    in c
           ( data_type) <another_data_type>

Answer 1

Use an explicit coercion function.

For example, fromIntegral will convert any Integral type ( Int , Integer , Word* , etc.) into any numeric type.

You can use Hoogle to find the actual function that suits your need by its type.

Answer 2

Haskell's type system is very different and quite a bit smarter then C/C++/Javas. To understand why you are not going to get the answer you expect, it will help to compare the two.

For C and friends the type is a way of describing the layout of data in memory. The compiler does makes a few sanity checks trying to ensure that memory is not corrupted, but in the end its all bytes and you can call them what ever you want. This is even more true of pointers which are always laid out the same in memory but can reference anything or (frighteningly) nothing.

In Haskell, types are a language that one writes to the compiler with. As a programmer you have no control over how the compiler represents data, and because haskell is lazy a lot of data in your program may be no more then a promise to produce a value on demand (called a thunk in the code GHC's and HUGS). While ac compiler can be instructed to treat data differently, there is no equivalent way to tell a haskell compiler to treat one type like another in general .

As mentioned in other answers, there are some types where there are obvious ways to convert one type to another. Any of the numerical types like Double, Fraction, or Real (in general any instance of the Num class) can be made from an Integer , but we need to use a function specifically designed to make this happen. In a sense this is not a 'cast' but an actual function in the same way that \\x -> x > 0 is a function for converting numbers into booleans.

I'll make one last guess as to why you might be asking a question like this. When I was just starting with haskell I wrote a lot of functions like:

area :: Double -> Double -> Double -- find the area of a rectangle
area x y = x * y

I would then find myself dumping fromInteger calls all over the place to get my data in the correct type for the function. Having come from a C background I wrote all my functions with monomorphic types. The trick to not needing to cast from one type to another is to write functions that work with different types. Haskell type classes are a huge shift for OOP programmers and so they often get ignored the first couple of tries, but they are what make the otherwise very strict haskell type system usable. If you can relax your type signatures (eg area :: (Num a)=> a -> a -> a ) you will find yourself wishing for that cast function much less often.

Answer 3

There are many different functions that convert different data types. The examples would be:

fromIntegral - to convert between say Int and Double

pack / unpack - to convert between ByteString and String

read - to convert from String to Int