Haskel. Преобразование типов.

realToFrac и fromIntegral - твои друзья

из Double Int

А это округление же: round / ceiling / floor

А можно с примерами? realToFrac -это как раз во Fractional а fromIntegral - это в Num

Что-то я не нашёл с ходу, как ими решить в своём вопросе

Да, я понимаю - округление. Сорри, не упомянул в основном посте. А просто для интереса - чего-то низкоуровневого «на коленке» нет разве? Только функциями, описанными в Prelude ?

Что-то я не нашёл с ходу, как ими решить в своём вопросе

Полиморфизм же.

round :: (RealFrac a, Integral b) => a -> b

Double это RealFrac, Int это Integral.

Hoogle твой лучший друг: http://www.haskell.org/hoogle/?hoogle=Real a => a -> Integer

Это все ф-ии классов типов (или их композиции). На месте могут через низкоуровневые определяться, в зависимости от конкретных типов. Можно взять decodeFloat и преобразовать в Int руками. Только зачем?

Вернее так: http://www.haskell.org/hoogle/?hoogle=(RealFrac a, Integral b) => a -> b

Только это не «преобразование типов», а просто функция ∷ Double → Int с заданным поведением. Преобразование типов тоже есть, но оно тебе не нужно.

Мне хочется понять все эти процессы. Я в С не сталкивался с таким вот :)

Ты не в тему: хотя бы «Double -> Int» привел как в оригинале. Если знать, что искать, то hoogle не нужен. В данном конкретном случае лучше Prelude посмотреть и иерархию числовых типов.

Но вот как её написать? :)

http://darcs.brianweb.net/packages/base/GHC/Float.lhs

Hoogle достаточно умён. В своё время я всякие truncate и fromIntegral нашёл именно через него, вбивая Float -> Integer.

Hoogle достаточно умён.  — есть «слишком базовые» вещи и для него

fromIntegral

Свежо приданье: выводит лишь toInteger, все равно надо смотреть Prelude и увидеть, что эта ф-ия входит в fromIntegral.

Я не говорил, что всё будет находиться в первой итерации, и не говорил, что остальные обитатели треда в чём неправы. Просто показал удобный способ поиска «того, не знаю чего». Что взъелся-то?

Ибо больше на дешевый понт похоже.

«лучший друг», а потом чудесным образом «Real a => a -> Integer» заместо «Double -> Int»

удобный способ поиска «того, не знаю чего».

Но не в этом случае. Я лишь заметил, что это не лучший use-case для hoogle.

Ибо больше на дешевый понт похоже.

К психологу сходи. У тебя подростковые проблемы какие-то.

К сожалению не подросток, а то мог у тебя адресок специалиста попросить.

// BTW, учитывая некоструктивность твоего поста, слив защитан, можешь больше не тужиться (ну разве что на местную публику поработать)

Что я, собственно, хотел добавить ко всему сказанному выше. Что есть замечательный сервис под названием hoogle, который помогает найти функцию, не зная её названия, только по сигнатуре.

Твой запрос, фактически, заключается в поиске функции с сигнатурой Double -> Int. Или, учитывая всё сказанное выше, скорее (RealFrac a, Integral b) => a -> b. То есть это идеальный use-case данной поисковой системы.

Итак, я просто хотел поделиться полезным инструментом. Если мой тон показался вам высокомерным, или вы приняли эту скупую информацию как вызов, уточняю, что я ничего подобного не имел в виду.

Мне хочется понять все эти процессы.

doubleToInt = round :: Double -> Int

при использовании же round непосредственно данная спецификация будет автоматически осуществляться компилятором всякий раз как будут выведены типы Double и Int для аргумента и результата соответственно.

Я в С не сталкивался с таким вот :)

В Си, к сожалению, нет ни параметрического, ни ad-hoc полиморфизма, ни модулей.

Это довольно интересный вопрос. Сначала делаем вот так:

Prelude> :i Double 
data Double = GHC.Types.D# GHC.Prim.Double#
        -- Defined in `GHC.Types'
instance Enum Double -- Defined in `GHC.Float'
instance Eq Double -- Defined in `GHC.Classes'
instance Floating Double -- Defined in `GHC.Float'
instance Fractional Double -- Defined in `GHC.Float'
instance Num Double -- Defined in `GHC.Float'
instance Ord Double -- Defined in `GHC.Classes'
instance Read Double -- Defined in `GHC.Read'
instance Real Double -- Defined in `GHC.Float'
instance RealFloat Double -- Defined in `GHC.Float'
instance RealFrac Double -- Defined in `GHC.Float'
instance Show Double -- Defined in `GHC.Float'

Для начала нас должно заинтересовать что Double это Enum. Enum'ы это типы для которых есть succ и pred, что в нашем случае несколько странно может быть полезно. Смотрим:

Prelude> :i Enum 
class Enum a where
  succ :: a -> a
  pred :: a -> a
  toEnum :: Int -> a
  fromEnum :: a -> Int
  enumFrom :: a -> [a]
  enumFromThen :: a -> a -> [a]
  enumFromTo :: a -> a -> [a]
  enumFromThenTo :: a -> a -> a -> [a]
        -- Defined in `GHC.Enum'
instance Enum Ordering -- Defined in `GHC.Enum'
instance Enum Integer -- Defined in `GHC.Enum'
instance Enum Int -- Defined in `GHC.Enum'
instance Enum Char -- Defined in `GHC.Enum'
instance Enum Bool -- Defined in `GHC.Enum'
instance Enum () -- Defined in `GHC.Enum'
instance Enum Float -- Defined in `GHC.Float'
instance Enum Double -- Defined in `GHC.Float'

И видим, что преобразование Enum'а к Enum'у в общем виде сводится к:

toEnum . fromEnum

Но в нашем случае будет вполне достаточно fromEnum. Затем решаем что это какой-то странный способ и смотрим все остальные классы. И вот оно:

Prelude> :i RealFrac 
class (Real a, Fractional a) => RealFrac a where
  properFraction :: Integral b => a -> (b, a)
  truncate :: Integral b => a -> b
  round :: Integral b => a -> b
  ceiling :: Integral b => a -> b
  floor :: Integral b => a -> b
        -- Defined in `GHC.Real'
instance RealFrac Float -- Defined in `GHC.Float'
instance RealFrac Double -- Defined in `GHC.Float'

Различные функции округления.

Но если хочешь, ты можешь сериализовать Double в ByteString (или список Word8'ов) и преобразовывать как в C.

сериализовать Double в ByteString (или список Word8'ов) и преобразовывать как в C

Можно сделать unsafeCoerce :: Double -> Int64:

> printf "%x\n" (unsafeCoerce 2.1 :: Int64)
4000cccccccccccd

и дальше по IEEE 754.

Или так:

        .text
foo:
        cvttsd2siq %xmm0, %rax

foreign import ccall foo :: Double -> Int64

http://darcs.brianweb.net/packages/base/GHC/Float.lhs

Now, here's Lennart's code (which works)

ОН!

И никто не предложил самого простого: при делении использовать функцию div. Один минус, оно не округляет а просто обрезает.