- Beginners - Haskell.org

Beginner question.
by Brad Smith 12 Sep '23

12 Sep '23

I just started working my way through a Haskell book... first time with functional programming. Mid way through the first chapter she's introducing point-free programming with a trivial example transitioning from not point-free... makeGreeting salutation person = salutation <> " " <> person to point free... makeGreeting' = (<>) . (<> " ") After a little playing with it... it seems to make sense. So I thought I'd try evolving from salutation and name to salutation, first, and last names. But, after a bit of tinkering, I haven't been able to make it work... I'm sure it's something simple (one way or the other)... any help would be appreciated! Brad

3 2

Show encoded string of JWT / Crypto.JWT
by Pietro Grandinetti 04 Mar '23

04 Mar '23

Hello- I am working with this package: I created a `SignedJWT` object, but cannot find a way to print it in the standard string form. I mean the string that would be used by clients, for example to send it in the "Authorization: Bearer ..." header of a HTTP request. Like this one: "eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJzdWIiOiIxMjM0NTY3ODkwIiwibmFtZSI6IkpvaG4gRG9lIiwiaWF0IjoxNTE2MjM5MDIyfQ.SflKxwRJSMeKKF2QT4fwpMeJf36POk6yJV_adQssw5c" ghci> jwt <- ... -- some code ghci> :t jwt jwt :: Either JWTError SignedJWT ghci> show jwt "Right JWS Base64Octets \"{\\\"aud\\\":\\\"bob\\\",\\\"iat\\\":1.677940566501089259e9,\\\"iss\\\":\\\"alice\\\"}\" Identity (Signature Nothing (JWSHeader {_jwsHeaderAlg = HeaderParam () PS512, _jwsHeaderJku = Nothing, _jwsHeaderJwk = Nothing, _jwsHeaderKid = Nothing, _jwsHeaderX5u = Nothing, _jwsHeaderX5c = Nothing, _jwsHeaderX5t = Nothing, _jwsHeaderX5tS256 = Nothing, _jwsHeaderTyp = Nothing, _jwsHeaderCty = Nothing, _jwsHeaderCrit = Nothing}) (Base64Octets \"\\DC2\\DC4\\151`\\131\\229j\\SI,\\178-\\CAN\\191UV-\\191u\\160\\217\\NAK\\247a\\150\\159\\195\\141=\\176\\212\\197\\209\\&8u+\\SIn\\DLE]\\167\\153\\SO\\142t\\163^\\EMW\\NAKt\\252\\b\\142j\\209^\\169j\\180 /U*^\\184\\t\\ESC\\DC4:\\DC4\\191\\150\\150\\192\\145\\FS\\172W!\\197\\190\\193\\RSx\\216\\244\\188\\168\\141\\213|\\EM\\174\\219\\230\\130b\\157\\130:\\b)\\n\\158\\169\\228?\\179\\177\\188\\234[N3\\ETX\\162\\230C\\167\\130V'V\\246\\240\\193\\243@\\SYN\\GS\\228\\157\\248\\161{\\131\\204=fI\\SYN\\GSZ\\149\\&8\\139\\a\\153\\a3\\nt\\185\\222\\&4\\FS\\EM\\171\\NUL2\\GS\\211,8CE(\\230\\240j\\150\\253\\204\\255\\188\\141\\250-:\\ESCx;3\\163K7\\137>\\145\\&0\\186\\194U0;\\b\\206\\221)C\\SOHX\\233?\\160\\168VqY\\160\\218\\&1\\224v\\f\\215[\\n\\231\\243a>\\212\\241\\237b\\138\\251eb\\207\\217\\t\\NUL\\138\\DC3\\184\\142I\\132\\154\\213\\139\\171\\137\\214\\ETX\\250\\198xn\\GS\\137\\182\\161b\\183\\f\\195\\231(\\202\\196\\177\\SI\\222\\193\\245Dv\\199\\156\\239D\\181.\\189\\153\\EOT\\SUB\\158\\160x\\135\\169$\\226\\DC3\\132\\198\\204$\\229\\&2ZTaG\\168\\203\\188\\v\\250\\SI\\214\\176;xkx\\170C\\DLE\\228\\NULc\\200r-\\205z\\243\\246\\NUL\\212Qx\\DLE!\\182\\188^\\STX\\244@\\252\\SI\\253_L\\165\\128g\\136\\197\\NUL\\201Cb\\vm\\238_>}F6\\193[As\\v\\222\\209\\146\\206\\215\\174\\&9\\NAK`E\\253\\199\\237\\236'\\149o9\\141\\130\\138\\DEL;\\NAK\\ESC\\225\\189\\170\\&1\\SUB\\CAN\\178U\\ETBL\\216G\\251\\218\\137\\191\\SYN\\193(\\DC4q\\196T\\174>@y\\198\\&4R\\138\\155~H\\DEL\\135\\202\\236\\&0\\219\\136r\\ETX\\138\\174js\\192^\\238\\193L\\204|x\\170\\140B\\158\\f\\164>2\\166\\156*W\\\\\\130\\160*\\230a\\DC3\\173m'\\DELm\\FSS[?6\\206\\170\\ESC\\145MKS=\\164Ec0\\EM\\177\\&4whq\\194\\ACKM\\147\\210\\183\\228\\161\\136\\162{\\166\\226\\174g\\241\\210\\223b\\190\\&5\\229\\212\"))"

1 1

Re: [Haskell-beginners] Understanding reason for Monad
by Travis Cardwell 01 Mar '23

01 Mar '23

Hi Pietro, The example in my previous message is that of a web application where the user registration request handler needs to write to a database as well as perform logging. In a production server, connecting to a database usually requires some configuration, and a pool of database connections is kept open and reused for improved performance. Similarly, logging may require configuration that the whole application needs to use in order to log consistently, and a resource may be kept open depending on how logging is configured. The server can initialize this state and provide it to various components such as request handlers. This state is what I referred to as a "context." It can be passed explicitly as arguments, but there are various other ways to manage it. For example, one popular design is to use a "Reader" monad, which essentially passes the state as an implicit argument to all functions that use the monad. Type classes such as `MonadDatabase` or `MonadLogger` may provide database and logging APIs utilizing the state made available by the Reader. Providing a meaningful minimal example is difficult because this type of abstraction is most beneficial in large applications, but here is a Reader example that is minimal for the points that I want to make: module Main (main) where -- https://hackage.haskell.org/package/base import Control.Monad.IO.Class (MonadIO(liftIO)) import Data.Bool (bool) import System.Environment (getArgs) -- https://hackage.haskell.org/package/transformers import Control.Monad.Trans.Reader (ReaderT(runReaderT), asks) data Locale = En | It class HasLocale a where getLocale :: a -> Locale instance HasLocale Locale where getLocale = id class MonadLocale m where askLocale :: m Locale instance (HasLocale r, Monad m) => MonadLocale (ReaderT r m) where askLocale = asks getLocale putLanguage :: (MonadIO m, MonadLocale m) => m () putLanguage = do locale <- askLocale liftIO . putStrLn $ case locale of En -> "English" It -> "Italiano" putHelloWorld :: (MonadIO m, MonadLocale m) => m () putHelloWorld = do locale <- askLocale liftIO . putStrLn $ case locale of En -> "Hello world!" It -> "Ciao mondo!" app :: (MonadIO m, MonadLocale m) => m () app = do putLanguage putHelloWorld main :: IO () main = do locale <- bool En It . elem "--it" <$> getArgs runReaderT app locale In this example, the state/context is simply a `Locale` value, which defaults to `En`. The `main` function checks if string `--it` is passed as an argument and configures the locale to `It` in that case. The final line runs the `app` function using a `ReaderT` monad transformer with the locale as the "environment." The `app` function, as well as all functions that it calls in the same monad, have access to this environment. Type class `HasLocale` just provides a `getLocale` function for getting a `Locale` value from some possibly larger value. The instance is the trivial case of `Locale` itself. Type class `MonadLocale` provides a locale API, just `askLocale` in this case. In a monad that implements `MonadLocale`, the `askLocale` function is able to get the locale. The instance provides a way to do this in a Reader monad that has an environment with a `HasLocale` instance. In this minimal example, the Reader environment is a `Locale` value, so that trivial `HasLocale` instance is used. The remaining three functions implement the example application. They do not specify a concrete monad; they instead specify constraints on the monad, allowing them to run in any monad that meets those constraints. The `MonadIO m` constraint is required to use `liftIO . putStrLn` in order to print to the screen, and the `MonadLocale m` constraint is required to get the configured locale. In this example, they are run in concrete monad `ReaderT Locale IO`, but note that they could also be run in different monads as long as the constraints are satisfied. The `app` function calls `putLanguage` and then `putHelloWorld`, and both of these functions are able to use `askLocale` to get the configured locale. $ minimal-context English Hello world! $ minimal-context --it Italiano Ciao mondo! The architecture/design of a project/program depends on the needs. In some programs, explicitly passing context as arguments is the best approach. In others, even `MonadIO` should be avoided, since `IO` makes anything possible. Getting back to your original question, the use of type classes allows a library author to implement functions that work across a wide variety of coding styles. Cheers, Travis On Sun, Feb 26, 2023 at 6:35 PM Pietro Grandinetti <pietro.gra(a)hotmail.it> wrote: > Hi Travis, > > Thanks. This was indeed helpful. I think I haven't grasped the concept of "context" yet. Do you know any minimal example that shows this? > > Thanks.

2 2

Reproduce example in Crypto.JWT
by Pietro Grandinetti 26 Feb '23

26 Feb '23

I am try to reproduce the first example here: https://hackage.haskell.org/package/jose-0.10/docs/Crypto-JWT.html I can't seem to succeed with importing the function `runJOSE` ghci> import Crypto.JWT ghci> :t runJOSE <interactive>:1:1: error: Variable not in scope: runJOSE ghci> import Crypto.JOSE.Error --https://github.com/frasertweedale/hs-jose/blob/master/src/Crypto/JOSE/Error.hs ghci> :t runJOSE <interactive>:1:1: error: Variable not in scope: runJOSE Can you point out what I am missing? Thanks.

2 4

Understanding reason for Monad
by Pietro Grandinetti 22 Feb '23

22 Feb '23

Hello-- I am going to use the function 'hashPassword' in [1] and I am not able to understand why the result is MonadRandom ByteArray instead of simply being a ByteString (or, ByteArray, or similar). Looking at [2], the only useful thing I can do with a MonadRandom a is to convert it to IO a. Why would a result of this determistic computation be a IO? [1] - https://hackage.haskell.org/package/cryptonite-0.30/docs/Crypto-KDF-BCrypt.… [2] - https://hackage.haskell.org/package/cryptonite-0.30/docs/Crypto-Random-Type…

3 3

Attoparsec.ByteString.Char8 or Attoparsec.ByteString for diff output?
by Pedro B. 20 Feb '23

20 Feb '23

Dear Listers, I am developing a program to parse dif output taken from stdin (as in diff file1 file2 | myApp) or from a file. I am reading the input as ByteString in either case and I am parsing it Attoparsec. My question is, Should I use Data.Attoparsec.ByteString.Char8 or Data.Attoparsec.ByteString? So far, I've been using Data.Attoparsec.ByteString.Char8 and it works for my sample files, which are in utf8 or, latin1, or the default Windows encoding. What do you suggest? Regards, Pedro Borges

2 2

Generic use of queries postgresql-simple
by Pietro Grandinetti 09 Feb '23

09 Feb '23

Hello-- I use postgresql-simple and for selecting rows from one table I have the following function. runMyQuery :: Connection -> String -- query with '?' params to bind -> Int -- first param -> Int -- second param -> IO [MyTable1] runMyQuery conn dbQuery param1 param2 = query conn dbQuery $ (param2, param2) data MyTable1 = MyTable1 {col1 :: Int, col2 :: Int, col3 :: String} instance FromRow MyTable1 where fromRow = MyTable1 <$> field <*> field <*> field <*> field There are some things I'd like to improve: 1. I will have to write "MyTable1", "MyTable2", ... datatypes, one for each table, but would like to have only one function runMyQuery where the return type is a generic IO [MyModel]. My problem is that I don't know how to write it for tables with different number of columns and different SQL types. 2. The 2nd to the penultimate arguments of runMyQuery are the arguments to bind into the SQL string query. This means that I should write several different version of "runMyQuery" each with a different number of arguments, but would like to have only one. Can you recommend some approaches? Thanks.

1 0

ways to use local ghc without installing packages via cabal install --lib
by Dennis Raddle 17 Jan '23

17 Jan '23

I have a situation where I build some projects with stack (using VS Code and HLS) and build some projects with ghc installed via ghcup. For the latter I need to install the needed packages with cabal install --lib <package> which are some of the same packages specified in my stack.yaml. I've been playing with Windows, macOS, various versions of the resolver, various versions of GHC, cabal, and stack. At one point I had both the HLS and my local ghc builds working. Recently I'm not sure what changed but I found myself needing to run cabal install --lib on many packages. At that point HLS stopped working with the message that it could not determine the local GHC version. After poking around the web, it seems that similar problems were happening for other people when they were running both a stack project and compiling via ghc separately, and that cabal install --lib was a problem. So I'm wondering if there's an alternative way of using separate ghc builds. Alternatively I can try to move everything under stack, that is doable, but not as convenient for some things

1 0

Question on fromIntegral
by Jonathan Drews 01 Dec '22

01 Dec '22

Hi Folks: I am using Glasgow Haskell Compilation System, version 9.2.4 on OpenBSD 7.2. I am stumped by the following problem. If I run the following program in ghci, then it works fine. Look: fact :: Integer -> Integer fact n = product [1..n] term :: Double -> Double term x = x**4/fromIntegral(fact(4)) $ ghci GHCi, version 9.2.4: https://www.haskell.org/ghc/ :? for help ghci> :l seriesTermTest.hs [1 of 1] Compiling Main ( seriesTermTest.hs, interpreted ) Ok, one module loaded. ghci> term 1.0 4.1666666666666664e-2 However if I use fromIntegral inside a list comprehension like so: fact :: Integer -> Integer fact n = product [1..n] expon :: Double -> Double expon x = sum [x**i/fromIntegral(fact(i)) | i <- [0..50]] then I get the following error message: $ ghci GHCi, version 9.2.4: https://www.haskell.org/ghc/ :? for help ghci> :l ePowerSeries.hs [1 of 1] Compiling Main ( ePowerSeries.hs, interpreted ) ePowerSeries.hs:6:40: error: * Couldn't match expected type `Integer' with actual type `Double' * In the first argument of `fact', namely `(i)' In the first argument of `fromIntegral', namely `(fact (i))' In the second argument of `(/)', namely `fromIntegral (fact (i))' | 6 | expon x = sum [x**i/fromIntegral(fact(i)) | i <- [0..50]] | ^ Failed, no modules loaded. What am I doing wrong? -- Kind regards, Jonathan

2 2

How to create a monad in GHC 7.10 or newer
by Ahmad Ismail 13 Nov '22

13 Nov '22

In the book "Haskell programming from first principles" it is said that: If you are using GHC 7.10 or newer, you’ll see an Applicative constraint in > the deﬁnition of Monad, as it should be: class Applicative m => Monad m where > (>>=) :: m a -> (a -> m b) -> m b > (>>) :: m a -> m b -> m b > return :: a -> m a I have created the following applicative functor. data WhoCares a = ItDoesnt | Matter a | WhatThisIsCalled deriving (Eq, Show) instance Functor WhoCares where fmap _ ItDoesnt = ItDoesnt fmap _ WhatThisIsCalled = WhatThisIsCalled fmap f (Matter a) = Matter (f a) instance Applicative WhoCares where pure = Matter Matter f <*> Matter a = Matter (f a) main = do -- fmap id == id let funcx = fmap id "Hi Julie" let funcy = id "Hi Julie" print(funcx) print(funcy) print(funcx == funcy) -- fmap (f . g) == fmap f . fmap g let funcx' = fmap ((+1) . (*2)) [1..5] let funcy' = fmap (+1) . fmap (*2) $ [1..5] print(funcx') print(funcy') print(funcx' == funcy') -- pure id <*> v = v print(pure id <*> (Matter 10)) -- pure (.) <*> u <*> v <*> w = u <*> (v <*> w) let appx = pure (.) <*> (Matter (+1)) <*> (Matter (*2)) <*> (Matter 10) let appy = (Matter (+1)) <*> ((Matter (*2)) <*> (Matter 10)) print(appx) print(appy) print(appx == appy) -- pure f <*> pure x = pure (f x) let appx' = pure (+1) <*> pure 1 :: WhoCares Int let appy' = pure ((+1) 1) :: WhoCares Int print(appx') print(appy') print(appx' == appy') -- u <*> pure y = pure ($ y) <*> u let appx'' = Matter (+2) <*> pure 2 let appy'' = pure ($ 2) <*> Matter (+ 2) print(appx'') print(appy'') print(appx'' == appy'') Due to lack of examples, I am not understanding how to implement >>= and >>. The code I came up with so far is: instance Monad (WhoCares a) where (>>=) :: Matter a -> (a -> Matter b) -> Matter b (>>) :: Matter a -> Matter b -> Matter b return :: a -> Matter a return = pure So, that I can do stuff like: half x = if even x then Matter (x `div` 2) else ItDoesnt incVal :: (Ord a, Num a) => a -> WhoCares a incVal x | x + 1 <= 10 = return (x + 1) | otherwise = ItDoesnt decVal :: (Ord a, Num a) => a -> WhoCares a decVal x | x - 1 >= 0 = return (x - 1) | otherwise = ItDoesnt main = do print (Matter 7 >>= incVal >>= incVal >>= incVal) print (Matter 7 >>= incVal >>= incVal >>= incVal >>= incVal) print (Matter 7 >>= incVal >>= incVal >>= incVal >>= incVal >>= decVal >>= decVal) print (Matter 2 >>= decVal >>= decVal >>= decVal) print(Matter 20 >>= half >>= half) With Output: 10 ItDoesnt ItDoesnt ItDoesnt 5 Please help. *Thanks and Best Regards,Ahmad Ismail*

2 4