Send Beginners mailing list submissions to
[email protected]
To subscribe or unsubscribe via the World Wide Web, visit
http://www.haskell.org/mailman/listinfo/beginners
or, via email, send a message with subject or body 'help' to
[email protected]
You can reach the person managing the list at
[email protected]
When replying, please edit your Subject line so it is more specific
than "Re: Contents of Beginners digest..."
Today's Topics:
1. List of all prelude function types? (Patrick LeBoutillier)
2. Re: List of all prelude function types? (Paulo Pocinho)
3. Re: List of all prelude function types? (Felipe Almeida Lessa)
4. TLS, PGP and maybe more crypto-stuff (Mateusz Neumann)
5. Re: TLS, PGP and maybe more crypto-stuff (Lorenzo Bolla)
----------------------------------------------------------------------
Message: 1
Date: Wed, 19 Oct 2011 13:25:48 -0400
From: Patrick LeBoutillier <[email protected]>
Subject: [Haskell-beginners] List of all prelude function types?
To: beginners <[email protected]>
Message-ID:
<cajcqsbgfsy8oxyd8gxqfiu3jcrfma7vkfcvmzz-hd5v85db...@mail.gmail.com>
Content-Type: text/plain; charset=ISO-8859-1
Hi,
Does anyone know where I can find a list of types for all Prelude
functions? Something like:
all :: (a -> Bool) -> [a] -> Bool
and :: [Bool] -> Bool
...
zip :: [a] -> [b] -> [(a, b)]
Thanks,
Patrick
--
=====================
Patrick LeBoutillier
Rosem?re, Qu?bec, Canada
------------------------------
Message: 2
Date: Wed, 19 Oct 2011 18:29:59 +0100
From: Paulo Pocinho <[email protected]>
Subject: Re: [Haskell-beginners] List of all prelude function types?
To: Patrick LeBoutillier <[email protected]>
Cc: beginners <[email protected]>
Message-ID:
<cak4i1qt2gbnfqybkbwjydg2biys4z5kqq89twewbqxgzd4e...@mail.gmail.com>
Content-Type: text/plain; charset=UTF-8
http://www.haskell.org/ghc/docs/latest/html/libraries/base-4.4.0.0/Prelude.html
Is this what you're after?
Regards,
Paulo M. Pocinho
On 19 October 2011 18:25, Patrick LeBoutillier
<[email protected]> wrote:
> Hi,
>
> Does anyone know where I can find a list of types for all Prelude
> functions? Something like:
>
> all :: (a -> Bool) -> [a] -> Bool
> and :: [Bool] -> Bool
> ...
> zip :: [a] -> [b] -> [(a, b)]
>
>
> Thanks,
>
> Patrick
> --
> =====================
> Patrick LeBoutillier
> Rosem?re, Qu?bec, Canada
>
> _______________________________________________
> Beginners mailing list
> [email protected]
> http://www.haskell.org/mailman/listinfo/beginners
>
------------------------------
Message: 3
Date: Wed, 19 Oct 2011 15:31:21 -0200
From: Felipe Almeida Lessa <[email protected]>
Subject: Re: [Haskell-beginners] List of all prelude function types?
To: Patrick LeBoutillier <[email protected]>
Cc: beginners <[email protected]>
Message-ID:
<CANd=OGFZ=5w9ti7q67ytyvukloh22qrtuhrampuvdkze45h...@mail.gmail.com>
Content-Type: text/plain; charset=UTF-8
You can see it on Hackage. Just click on Synopsis here:
http://hackage.haskell.org/packages/archive/base/4.4.0.0/doc/html/Prelude.html
.
Also, GHCi can tell you that for any module using :browse.
$ ghci
GHCi, version 7.0.3: http://www.haskell.org/ghc/ :? for help
Loading package ghc-prim ... linking ... done.
Loading package integer-gmp ... linking ... done.
Loading package base ... linking ... done.
Loading package ffi-1.0 ... linking ... done.
Prelude> :browse Prelude
($!) :: (a -> b) -> a -> b
(!!) :: [a] -> Int -> a
($) :: (a -> b) -> a -> b
(&&) :: Bool -> Bool -> Bool
(++) :: [a] -> [a] -> [a]
(.) :: (b -> c) -> (a -> b) -> a -> c
(=<<) :: Monad m => (a -> m b) -> m a -> m b
data Bool = False | True
class Bounded a where
minBound :: a
maxBound :: a
data Char = GHC.Types.C# GHC.Prim.Char#
data Double = GHC.Types.D# GHC.Prim.Double#
data Either a b = Left a | Right b
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]
class Eq a where
(==) :: a -> a -> Bool
(/=) :: a -> a -> Bool
type FilePath = String
data Float = GHC.Types.F# GHC.Prim.Float#
class Fractional a => Floating a where
pi :: a
exp :: a -> a
sqrt :: a -> a
log :: a -> a
(**) :: a -> a -> a
logBase :: a -> a -> a
sin :: a -> a
tan :: a -> a
cos :: a -> a
asin :: a -> a
atan :: a -> a
acos :: a -> a
sinh :: a -> a
tanh :: a -> a
cosh :: a -> a
asinh :: a -> a
atanh :: a -> a
acosh :: a -> a
class Num a => Fractional a where
(/) :: a -> a -> a
recip :: a -> a
fromRational :: Rational -> a
class Functor f where
fmap :: (a -> b) -> f a -> f b
(GHC.Base.<$) :: a -> f b -> f a
newtype IO a
= GHC.Types.IO (GHC.Prim.State# GHC.Prim.RealWorld
-> (# GHC.Prim.State# GHC.Prim.RealWorld, a #))
type IOError = GHC.IO.Exception.IOException
data Int = GHC.Types.I# GHC.Prim.Int#
data Integer
= integer-gmp:GHC.Integer.Type.S# GHC.Prim.Int#
| integer-gmp:GHC.Integer.Type.J# GHC.Prim.Int# GHC.Prim.ByteArray#
class (Real a, Enum a) => Integral a where
quot :: a -> a -> a
rem :: a -> a -> a
div :: a -> a -> a
mod :: a -> a -> a
quotRem :: a -> a -> (a, a)
divMod :: a -> a -> (a, a)
toInteger :: a -> Integer
data Maybe a = Nothing | Just a
class Monad m where
(>>=) :: m a -> (a -> m b) -> m b
(>>) :: m a -> m b -> m b
return :: a -> m a
fail :: String -> m a
class (Eq a, Show a) => Num a where
(+) :: a -> a -> a
(*) :: a -> a -> a
(-) :: a -> a -> a
negate :: a -> a
abs :: a -> a
signum :: a -> a
fromInteger :: Integer -> a
class Eq a => Ord a where
compare :: a -> a -> Ordering
(<) :: a -> a -> Bool
(>=) :: a -> a -> Bool
(>) :: a -> a -> Bool
(<=) :: a -> a -> Bool
max :: a -> a -> a
min :: a -> a -> a
data Ordering = LT | EQ | GT
type Rational = GHC.Real.Ratio Integer
class Read a where
readsPrec :: Int -> ReadS a
readList :: ReadS [a]
GHC.Read.readPrec :: Text.ParserCombinators.ReadPrec.ReadPrec a
GHC.Read.readListPrec ::
Text.ParserCombinators.ReadPrec.ReadPrec [a]
type ReadS a = String -> [(a, String)]
class (Num a, Ord a) => Real a where toRational :: a -> Rational
class (RealFrac a, Floating a) => RealFloat a where
floatRadix :: a -> Integer
floatDigits :: a -> Int
floatRange :: a -> (Int, Int)
decodeFloat :: a -> (Integer, Int)
encodeFloat :: Integer -> Int -> a
exponent :: a -> Int
significand :: a -> a
scaleFloat :: Int -> a -> a
isNaN :: a -> Bool
isInfinite :: a -> Bool
isDenormalized :: a -> Bool
isNegativeZero :: a -> Bool
isIEEE :: a -> Bool
atan2 :: a -> a -> a
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
class Show a where
showsPrec :: Int -> a -> ShowS
show :: a -> String
showList :: [a] -> ShowS
type ShowS = String -> String
type String = [Char]
(^) :: (Num a, Integral b) => a -> b -> a
(^^) :: (Fractional a, Integral b) => a -> b -> a
all :: (a -> Bool) -> [a] -> Bool
and :: [Bool] -> Bool
any :: (a -> Bool) -> [a] -> Bool
appendFile :: FilePath -> String -> IO ()
asTypeOf :: a -> a -> a
break :: (a -> Bool) -> [a] -> ([a], [a])
catch :: IO a -> (IOError -> IO a) -> IO a
concat :: [[a]] -> [a]
concatMap :: (a -> [b]) -> [a] -> [b]
const :: a -> b -> a
curry :: ((a, b) -> c) -> a -> b -> c
cycle :: [a] -> [a]
drop :: Int -> [a] -> [a]
dropWhile :: (a -> Bool) -> [a] -> [a]
either :: (a -> c) -> (b -> c) -> Either a b -> c
elem :: Eq a => a -> [a] -> Bool
error :: [Char] -> a
even :: Integral a => a -> Bool
filter :: (a -> Bool) -> [a] -> [a]
flip :: (a -> b -> c) -> b -> a -> c
foldl :: (a -> b -> a) -> a -> [b] -> a
foldl1 :: (a -> a -> a) -> [a] -> a
foldr :: (a -> b -> b) -> b -> [a] -> b
foldr1 :: (a -> a -> a) -> [a] -> a
fromIntegral :: (Integral a, Num b) => a -> b
fst :: (a, b) -> a
gcd :: Integral a => a -> a -> a
getChar :: IO Char
getContents :: IO String
getLine :: IO String
head :: [a] -> a
id :: a -> a
init :: [a] -> [a]
interact :: (String -> String) -> IO ()
ioError :: IOError -> IO a
iterate :: (a -> a) -> a -> [a]
last :: [a] -> a
lcm :: Integral a => a -> a -> a
length :: [a] -> Int
lex :: ReadS String
lines :: String -> [String]
lookup :: Eq a => a -> [(a, b)] -> Maybe b
map :: (a -> b) -> [a] -> [b]
mapM :: Monad m => (a -> m b) -> [a] -> m [b]
mapM_ :: Monad m => (a -> m b) -> [a] -> m ()
maximum :: Ord a => [a] -> a
maybe :: b -> (a -> b) -> Maybe a -> b
minimum :: Ord a => [a] -> a
not :: Bool -> Bool
notElem :: Eq a => a -> [a] -> Bool
null :: [a] -> Bool
odd :: Integral a => a -> Bool
or :: [Bool] -> Bool
otherwise :: Bool
print :: Show a => a -> IO ()
product :: Num a => [a] -> a
putChar :: Char -> IO ()
putStr :: String -> IO ()
putStrLn :: String -> IO ()
read :: Read a => String -> a
readFile :: FilePath -> IO String
readIO :: Read a => String -> IO a
readLn :: Read a => IO a
readParen :: Bool -> ReadS a -> ReadS a
reads :: Read a => ReadS a
realToFrac :: (Real a, Fractional b) => a -> b
repeat :: a -> [a]
replicate :: Int -> a -> [a]
reverse :: [a] -> [a]
scanl :: (a -> b -> a) -> a -> [b] -> [a]
scanl1 :: (a -> a -> a) -> [a] -> [a]
scanr :: (a -> b -> b) -> b -> [a] -> [b]
scanr1 :: (a -> a -> a) -> [a] -> [a]
seq :: a -> b -> b
sequence :: Monad m => [m a] -> m [a]
sequence_ :: Monad m => [m a] -> m ()
showChar :: Char -> ShowS
showParen :: Bool -> ShowS -> ShowS
showString :: String -> ShowS
shows :: Show a => a -> ShowS
snd :: (a, b) -> b
span :: (a -> Bool) -> [a] -> ([a], [a])
splitAt :: Int -> [a] -> ([a], [a])
subtract :: Num a => a -> a -> a
sum :: Num a => [a] -> a
tail :: [a] -> [a]
take :: Int -> [a] -> [a]
takeWhile :: (a -> Bool) -> [a] -> [a]
uncurry :: (a -> b -> c) -> (a, b) -> c
undefined :: a
unlines :: [String] -> String
until :: (a -> Bool) -> (a -> a) -> a -> a
unwords :: [String] -> String
unzip :: [(a, b)] -> ([a], [b])
unzip3 :: [(a, b, c)] -> ([a], [b], [c])
userError :: String -> IOError
words :: String -> [String]
writeFile :: FilePath -> String -> IO ()
zip :: [a] -> [b] -> [(a, b)]
zip3 :: [a] -> [b] -> [c] -> [(a, b, c)]
zipWith :: (a -> b -> c) -> [a] -> [b] -> [c]
zipWith3 :: (a -> b -> c -> d) -> [a] -> [b] -> [c] -> [d]
(||) :: Bool -> Bool -> Bool
--
Felipe.
------------------------------
Message: 4
Date: Thu, 20 Oct 2011 09:28:28 +0200
From: Mateusz Neumann <[email protected]>
Subject: [Haskell-beginners] TLS, PGP and maybe more crypto-stuff
To: beginners <[email protected]>
Message-ID: <[email protected]>
Content-Type: text/plain; charset=US-ASCII
Hi
I am considering using Haskell in my next project. However the very
core of my application depends on strong cryptographic algorithms
securing communication. I thought about using GnuPG (PGP) but did not
find Haskell library (I admit, I did not search for long). So my idea
was to look into TLS based stuff, but here I found few different
libraries. For a moment I thought of developing something basing on
ECC, but again I did not find anything.
My questions are:
* is there a (decent) GnuPG (PGP) library in Haskell?
* what TLS (possibly 1.2) library would you suggest?
* is there a ECC library?
--
Mateusz
------------------------------
Message: 5
Date: Thu, 20 Oct 2011 09:19:34 +0100
From: Lorenzo Bolla <[email protected]>
Subject: Re: [Haskell-beginners] TLS, PGP and maybe more crypto-stuff
To: Mateusz Neumann <[email protected]>
Cc: beginners <[email protected]>
Message-ID:
<cadjgtryja-aelhw3hzpmwnaxd4r0vnkf7yv0qruyk3nusqm...@mail.gmail.com>
Content-Type: text/plain; charset="utf-8"
"cabal list pgp" returns openPGP:
https://github.com/singpolyma/OpenPGP-Haskell
"tls" and "hecc" are available from cabal, too.
hth,
L.
On Thu, Oct 20, 2011 at 8:28 AM, Mateusz Neumann <[email protected]>wrote:
> Hi
>
> I am considering using Haskell in my next project. However the very
> core of my application depends on strong cryptographic algorithms
> securing communication. I thought about using GnuPG (PGP) but did not
> find Haskell library (I admit, I did not search for long). So my idea
> was to look into TLS based stuff, but here I found few different
> libraries. For a moment I thought of developing something basing on
> ECC, but again I did not find anything.
>
> My questions are:
> * is there a (decent) GnuPG (PGP) library in Haskell?
> * what TLS (possibly 1.2) library would you suggest?
> * is there a ECC library?
>
> --
> Mateusz
>
> _______________________________________________
> Beginners mailing list
> [email protected]
> http://www.haskell.org/mailman/listinfo/beginners
>
-------------- next part --------------
An HTML attachment was scrubbed...
URL:
<http://www.haskell.org/pipermail/beginners/attachments/20111020/5329e339/attachment-0001.htm>
------------------------------
_______________________________________________
Beginners mailing list
[email protected]
http://www.haskell.org/mailman/listinfo/beginners
End of Beginners Digest, Vol 40, Issue 33
*****************************************
