to

toEnum :: Enum a => Int -> a
base Prelude
toInteger :: Integral a => a -> Integer
base Prelude
toRational :: Real a => a -> Rational
base Prelude
toBool :: Num a => a -> Bool
base Foreign.Marshal.Utils
Convert a Boolean in numeric representation to a Haskell value
toConstr :: Data a => a -> Constr
base Data.Data
toDyn :: Typeable a => a -> Dynamic
base Data.Dynamic
Converts an arbitrary value into an object of type Dynamic. The type of the object must be an instance of Typeable, which ensures that only monomorphically-typed objects may be converted to Dynamic. To convert a polymorphic object into Dynamic, give it a monomorphic type signature. For example: > toDyn (id :: Int -> Int)
toException :: Exception e => e -> SomeException
base Control.Exception.Base, base Control.Exception
toList :: HashTable key val -> IO [(key, val)]
base Data.HashTable
Converts a hash table to a list of key/value pairs.
toList :: Foldable t => t a -> [a]
base Data.Foldable
List of elements of a structure.
toLower :: Char -> Char
base Data.Char
Convert a letter to the corresponding lower-case letter, if any. Any other character is returned unchanged.
toTitle :: Char -> Char
base Data.Char
Convert a letter to the corresponding title-case or upper-case letter, if any. (Title case differs from upper case only for a small number of ligature letters.) Any other character is returned unchanged.
touchForeignPtr :: ForeignPtr a -> IO ()
base Foreign.ForeignPtr
This function ensures that the foreign object in question is alive at the given place in the sequence of IO actions. In particular Foreign.ForeignPtr.withForeignPtr does a touchForeignPtr after it executes the user action. Note that this function should not be used to express dependencies between finalizers on ForeignPtrs. For example, if the finalizer for a ForeignPtr F1 calls touchForeignPtr on a second ForeignPtr F2, then the only guarantee is that the finalizer for F2 is never started before the finalizer for F1. They might be started together if for example both F1 and F2 are otherwise unreachable, and in that case the scheduler might end up running the finalizer for F2 first. In general, it is not recommended to use finalizers on separate objects with ordering constraints between them. To express the ordering robustly requires explicit synchronisation using MVars between the finalizers, but even then the runtime sometimes runs multiple finalizers sequentially in a single thread (for performance reasons), so synchronisation between finalizers could result in artificial deadlock. Another alternative is to use explicit reference counting.
toUpper :: Char -> Char
base Data.Char
Convert a letter to the corresponding upper-case letter, if any. Any other character is returned unchanged.
package to-haskell
package
A type class and some utilities for generating Haskell code. Version 0.3.0
package to-string-class
package
This library provides the class: class ToString s where toString :: s -> String Instances for String, Char and ShowS are provided. For other instances see the package: http://hackage.haskell.org/package/to-string-instances Also included is a general coercion function between string-like types: fromToString :: (IsString s2, ToString s1) => s1 -> s2 fromToString = fromString . toString Version 0.1.2
package to-string-instances
package
This library provides the following instances for the ToString class: * ByteString * Doc * Text Note that the instances can be enabled or disabled based on cabal flags. The idea is that eventually all packages providing string-like types will provide instances for ToString themselves. In the mean time this package is here to provide them. Version 0.2
to_HPJ_Doc :: Doc -> Doc
template-haskell Language.Haskell.TH.PprLib
toAscList :: IntMap a -> [(Key, a)]
containers Data.IntMap.Strict, containers Data.IntMap.Lazy
O(n). Convert the map to a list of key/value pairs keys are in ascending order. Subject to list fusion. > toAscList (fromList [(5,"a"), (3,"b")]) == [(3,"b"), (5,"a")]
toAscList :: IntSet -> [Key]
containers Data.IntSet
O(n). Convert the set to an ascending list of elements. Subject to list fusion.
toAscList :: Map k a -> [(k, a)]
containers Data.Map.Lazy, containers Data.Map.Strict
O(n). Convert the map to a list of key/value pairs keys are in ascending order. Subject to list fusion. > toAscList (fromList [(5,"a"), (3,"b")]) == [(3,"b"), (5,"a")]

Show more results