- Beginners - Haskell.org

help
by Timothy Xu 22 Mar '25

22 Mar '25

help > Le 21 mars 2025 à 10:33, beginners-request(a)haskell.org a écrit : > > Send Beginners mailing list submissions to > beginners(a)haskell.org > > To subscribe or unsubscribe via the World Wide Web, visit > https://urldefense.proofpoint.com/v2/url?u=http-3A__mail.haskell.org_cgi-2D… > or, via email, send a message with subject or body 'help' to > beginners-request(a)haskell.org > > You can reach the person managing the list at > beginners-owner(a)haskell.org > > When replying, please edit your Subject line so it is more specific > than "Re: Contents of Beginners digest..." > > > Today's Topics: > > 1. Utrecht Summer School on Advanced Functional Programming > (Wouter Swierstra) > 2. Re: Utrecht Summer School on Advanced Functional Programming > (Vinod Parthasarathy) > 3. Re: Utrecht Summer School on Advanced Functional Programming > (Wouter Swierstra) > > > ---------------------------------------------------------------------- > > Message: 1 > Date: Thu, 20 Mar 2025 16:59:13 +0100 > From: Wouter Swierstra <w.s.swierstra(a)uu.nl> > To: beginners(a)haskell.org > Subject: [Haskell-beginners] Utrecht Summer School on Advanced > Functional Programming > Message-ID: <32bfd4d7-034c-4529-9bfc-b51efb1eb074(a)uu.nl> > Content-Type: text/plain; charset=UTF-8 > > > # Call for Participation > > SUMMER SCHOOL ON ADVANCED FUNCTIONAL PROGRAMMING > > Utrecht, the Netherlands, 07 July – 11 July 2025 > > https://urldefense.proofpoint.com/v2/url?u=http-3A__www.afp.school_&d=DwIGa… > > **Please register before June 15th ** > > ## ABOUT > > The Advanced Functional Programming summer school has been running for > more than fifteen years. We aim to educate aspiring Haskell programmers > beyond the basic material covered by many textbooks. > > The lectures will cover several more advanced topics regarding the > theory and practice of Haskell programming, including topics such as: > > * lambda calculus; > * lazy evaluation; > * generalized algebraic data types; > * type families and type-level programming; > * concurrency and parallelism. > > The summer school will be held in Utrecht and consists of a mix of > lectures, labs, and a busy social program. > > ## PREREQUISITES > > We expect students to have a basic familiarity with Haskell > already. You should be able to write recursive functions over > algebraic data types, such as lists and trees. There is a great deal > of material readily available that covers this material. If you've > already started learning Haskell and are looking to take your > functional programming skills to the next level, this is the course > for you. > > ## DATES > > Registration deadline: June 15th, 2025 > School: 07 July – 11 July 2025 > > ## COSTS > > € 950 euro - Profession registration fee > € 500 euro - Student registration fee > € 200 euro - Housing fee > > We will charge a registration fee of €950 (or €500 for students) to > cover our expenses. This fee includes all lunches, dinners, and coffee > breaks - you won't need to budget much else besides your travel. > > If this is problematic for you for any reason at all, please email the > organisers and we can try to offer you a discounted rate or a fee > waiver. We have a limited number of scholarships or discounts available > for students that would not be able to attend otherwise, especially for > women and under-represented minorities. > > ## FURTHER INFORMATION > > Further information, including instructions on how to register, is > available on our website: > > https://urldefense.proofpoint.com/v2/url?u=http-3A__afp.school_&d=DwIGaQ&c=… > > > ------------------------------ > > Message: 2 > Date: Fri, 21 Mar 2025 09:26:26 +0530 > From: Vinod Parthasarathy <vinnytryclyst(a)gmail.com> > To: The Haskell-Beginners Mailing List - Discussion of primarily > beginner-level topics related to Haskell <beginners(a)haskell.org> > Subject: Re: [Haskell-beginners] Utrecht Summer School on Advanced > Functional Programming > Message-ID: > <CAKO4ktShf1trcLFwkjB8mnqGhw5AtRj1+YjUnjnnQ6-bhQdV2w(a)mail.gmail.com> > Content-Type: text/plain; charset="utf-8" > > Hi, > I am from India and I am a Haskell beginner level programmer. I am > interested in the summer school, but I won’t be able to attend in person. > Is there a provision for attending the lectures online? Also, is any > discount or fee waiver possible in my case as I cannot afford the full > amount? > > Vinod. > > On Thu, 20 Mar 2025 at 9:29 PM, Wouter Swierstra <w.s.swierstra(a)uu.nl> > wrote: > >> >> # Call for Participation >> >> SUMMER SCHOOL ON ADVANCED FUNCTIONAL PROGRAMMING >> >> Utrecht, the Netherlands, 07 July – 11 July 2025 >> >> https://urldefense.proofpoint.com/v2/url?u=http-3A__www.afp.school_&d=DwIGa… >> >> **Please register before June 15th ** >> >> ## ABOUT >> >> The Advanced Functional Programming summer school has been running for >> more than fifteen years. We aim to educate aspiring Haskell programmers >> beyond the basic material covered by many textbooks. >> >> The lectures will cover several more advanced topics regarding the >> theory and practice of Haskell programming, including topics such as: >> >> * lambda calculus; >> * lazy evaluation; >> * generalized algebraic data types; >> * type families and type-level programming; >> * concurrency and parallelism. >> >> The summer school will be held in Utrecht and consists of a mix of >> lectures, labs, and a busy social program. >> >> ## PREREQUISITES >> >> We expect students to have a basic familiarity with Haskell >> already. You should be able to write recursive functions over >> algebraic data types, such as lists and trees. There is a great deal >> of material readily available that covers this material. If you've >> already started learning Haskell and are looking to take your >> functional programming skills to the next level, this is the course >> for you. >> >> ## DATES >> >> Registration deadline: June 15th, 2025 >> School: 07 July – 11 July 2025 >> >> ## COSTS >> >> € 950 euro - Profession registration fee >> € 500 euro - Student registration fee >> € 200 euro - Housing fee >> >> We will charge a registration fee of €950 (or €500 for students) to >> cover our expenses. This fee includes all lunches, dinners, and coffee >> breaks - you won't need to budget much else besides your travel. >> >> If this is problematic for you for any reason at all, please email the >> organisers and we can try to offer you a discounted rate or a fee >> waiver. We have a limited number of scholarships or discounts available >> for students that would not be able to attend otherwise, especially for >> women and under-represented minorities. >> >> ## FURTHER INFORMATION >> >> Further information, including instructions on how to register, is >> available on our website: >> >> https://urldefense.proofpoint.com/v2/url?u=http-3A__afp.school_&d=DwIGaQ&c=… >> _______________________________________________ >> Beginners mailing list >> Beginners(a)haskell.org >> https://urldefense.proofpoint.com/v2/url?u=http-3A__mail.haskell.org_cgi-2D… >> >

1 0

Utrecht Summer School on Advanced Functional Programming
by Wouter Swierstra 21 Mar '25

21 Mar '25

# Call for Participation SUMMER SCHOOL ON ADVANCED FUNCTIONAL PROGRAMMING Utrecht, the Netherlands, 07 July – 11 July 2025 http://www.afp.school/ **Please register before June 15th ** ## ABOUT The Advanced Functional Programming summer school has been running for more than fifteen years. We aim to educate aspiring Haskell programmers beyond the basic material covered by many textbooks. The lectures will cover several more advanced topics regarding the theory and practice of Haskell programming, including topics such as: * lambda calculus; * lazy evaluation; * generalized algebraic data types; * type families and type-level programming; * concurrency and parallelism. The summer school will be held in Utrecht and consists of a mix of lectures, labs, and a busy social program. ## PREREQUISITES We expect students to have a basic familiarity with Haskell already. You should be able to write recursive functions over algebraic data types, such as lists and trees. There is a great deal of material readily available that covers this material. If you've already started learning Haskell and are looking to take your functional programming skills to the next level, this is the course for you. ## DATES Registration deadline: June 15th, 2025 School: 07 July – 11 July 2025 ## COSTS € 950 euro - Profession registration fee € 500 euro - Student registration fee € 200 euro - Housing fee We will charge a registration fee of €950 (or €500 for students) to cover our expenses. This fee includes all lunches, dinners, and coffee breaks - you won't need to budget much else besides your travel. If this is problematic for you for any reason at all, please email the organisers and we can try to offer you a discounted rate or a fee waiver. We have a limited number of scholarships or discounts available for students that would not be able to attend otherwise, especially for women and under-represented minorities. ## FURTHER INFORMATION Further information, including instructions on how to register, is available on our website: http://afp.school/

2 2

Compiling project errors within a docker container
by Hercules Merscher 14 Jul '24

14 Jul '24

Hello folks, I've been developing a small side project (a small web app). I'm developing on a Macbook M1 Pro, however, I need to compile it to test against a linux/amd64 environment. I'm trying to use docker for that. I know it is emulated via VM in this case and performance will suffer, but it's not a big deal for me since it's just a toy project. I'm using stack as build tool and GHC 9.6. The `stack build --fast` command errors, hinting that it could be out of memory. ``` root@c5f07dbd83dc:/opt/app# stack build --fast -j 4 --allow-different-user ... Error: [S-7282] Stack failed to execute the build plan. While executing the build plan, Stack encountered the error: [S-7011] While building package rinha-0.1.0.0 (scroll up to its section to see the error) using: /root/.stack/setup-exe-cache/x86_64-linux/Cabal-simple_6HauvNHV_3.10.3.0_ghc-9.6.5 --verbose=1 --builddir=.stack-work/dist/x86_64-linux/ghc-9.6.5 build lib:rinha exe:rinha-exe --ghc-options " -fdiagnostics-color=always" Process exited with code: ExitFailure (-9) (THIS MAY INDICATE OUT OF MEMORY) ``` Initially, I thought it really could be out of memory as I'm using colima and had default configuration. Then I started colima giving it 4 CPUs and 16GiB memory: ``` $ colima start --cpu 4 --memory 16 -a x86_64 -t vz --vz-rosetta ``` The project starts building, stays like that for almost 1h, and then this error happens. I wouldn't like to spin up a server just to build a project that I will be running on my laptop, but I see myself without alternatives and I'm finding it weird since I never had such a problem with other languages and it's the first time I see it while doing some Haskell. Any tips? Best, Hercules

2 2

FFI. unIO safety considerations
by Folsk Pratima 13 Apr '24

13 Apr '24

Also see [Haskell-beginners] FFI to POSIX libc; strerror (errnum); unfreed memory Exactly how unsafe this code is? What do I do about it? It is so very stupid to have a pure function strerror_r in the IO monad! StrError.hs import Control.Exception import Control.Monad.ST import Control.Monad.ST.Unsafe import Data.Word import Foreign.C.String import Foreign.C.String import Foreign.C.Types import Foreign.Marshal import Foreign.Ptr import Foreign.Storable foreign import ccall unsafe "strerror_r_portalbe.c strerror_r_portable" c_strerror_r :: CInt -> Ptr CChar -> CSize -> IO CInt memSet :: Ptr a -> Word8 -> Word32 -> IO (Ptr a) memSet ptr _ 0 = return ptr memSet ptr byte size = do let voidptr = castPtr ptr :: Ptr Word8 acts = map (\i -> pokeByteOff voidptr i byte) [0 .. fromIntegral (size - 1)] mapM_ id acts return ptr strError :: Int -> String strError errnum = runST $ unsafeIOToST ioString where buflen = 512 :: CSize ioString = allocaBytes (fromIntegral buflen) $ \ptr -> do zeroptr <- memSet ptr 0 (fromIntegral buflen) code <- c_strerror_r (fromIntegral errnum) ptr buflen -- heuristic! case code of 22 -> return $ "Unknown error " ++ show errnum -- this is very dangerous, as far as I understand, and nobody in -- his right might should not do it if he later intends to -- unsafely escape IO 34 -> throwIO $ userError $ "strError: " ++ show code ++ ": ERANGE: " ++ "Numerical result out of range: " ++ "this is internal an error, which means not enough space " ++ "was allocated to store the error. You can not recover" _ -> peekCAString ptr main = mapM_ (putStrLn) $ map strError [1 .. 1000] strerror_portable.c #define _POSIX_C_SOURCE 200112L #include <string.h> int strerror_r_portable (int e, char *c, size_t s) { return strerror_r (e, c, s); } The C code is needed because GHC uses _GNU_SOURCE, which I personally do not want to use. Besides, I do not know how to predict whether GHC will define _GNU_SOURCE or not, so this also feels more reliable. To compile, do $ mkdir lib $ gcc -c -o lib/portable.o strerror_portable.c $ ar -csr lib/portable.a lib/portable.o $ ghc StrError.hs lib/portable.a No leaks, of course.

1 1

FFI to POSIX libc; strerror (errnum); unfreed memory
by Folsk Pratima 12 Apr '24

12 Apr '24

I need to turn POSIX errno to the error string. StrError.hs import Foreign.C.String import Foreign.C.Types foreign import ccall unsafe "strerror" c_strerror :: CInt -> IO CString strError :: Int -> IO String strError i = do cstr <- c_strerror ci peekCAString cstr where ci = fromIntegral i main = mapM_ (>>= putStrLn) $ map strError [1 .. 450] $ ghc -g StrError.hs $ valgrind --leak-check=full --show-leak-kinds=all ./StrError ==2350== ==2350== HEAP SUMMARY: ==2350== in use at exit: 18 bytes in 1 blocks ==2350== total heap usage: 685 allocs, 684 frees, 97,998 bytes allocated ==2350== ==2350== 18 bytes in 1 blocks are still reachable in loss record 1 of 1 ==2350== at 0x48407B4: malloc (vg_replace_malloc.c:381) ==2350== by 0x496A427: __vasprintf_internal (vasprintf.c:71) ==2350== by 0x493DBD5: asprintf (asprintf.c:31) ==2350== by 0x498A9F0: strerror_l (strerror_l.c:45) ==2350== by 0x408BC0: ??? (StrError.hs:8) ==2350== ==2350== LEAK SUMMARY: ==2350== definitely lost: 0 bytes in 0 blocks ==2350== indirectly lost: 0 bytes in 0 blocks ==2350== possibly lost: 0 bytes in 0 blocks ==2350== still reachable: 18 bytes in 1 blocks ==2350== suppressed: 0 bytes in 0 blocks ==2350== ==2350== For lists of detected and suppressed errors, rerun with: -s ==2350== ERROR SUMMARY: 0 errors from 0 contexts (suppressed: 0 from 0) I am already frustrated with having to use IO for this. I feel like it is better to manually create a pure solution by copying whatever the C code from libc does. But I still do not understand what causes this memory to remain reachable. Calling strerror from pure C code does not leave reachable memory regions. Can anyone explain? And maybe you have a suggestion as to how to implement this strError function properly? Just in case you are the type of a person to inquire as to *why* I need this, for fun. I need it for fun.

2 2

Question about Interpretation as Least Fixed Point from Denotational semantics article
by Dmitriy Matrosov 16 Jan '24

16 Jan '24

Hi. I'm reading denotational semantics article on haskell wikibook and don't understand following statement from the ["Interpretation as Least Fixed Point" chapter][1] chapter: > However, there might be multiple fixed points. For instance, there are > several f which fulfill the specification > > f = n -> if n == 0 then 1 else f (n + 1) > > Of course, when executing such a program, the machine will loop forever on > f(1) or f(2) and thus not produce any valuable information about the value > of f(1). What is this f exactly? If it's just another recursive function, like the factorial was before, then it has a little difference from it to me: the above f is defined on n <= 0 and not defined on n > 0. Whereas factorial is defined on other part of values. Thus, both functions will not produce any results on certain values, if such program is executed: for the above f this is f(1), f(2), etc, but for factorial this is f(-1), f(-2), etc (who prevents me from executing factorial program on negative integers, after all?). Both functions can be approximated using corresponding functional g and fixed point iteration scheme, like was explained in the article earlier: x0, g(x0), g(g(x0)), .. where x0 == _|_ . So, essentially this functions looks to me exactly the same as factorial and i don't understand what this example is supposed to show? If the right hand side is functional g' defined as g'(f) = n -> if n == 0 then 1 else f (n + 1) and we try to find it's fixed point, i.e. such f, that f = g'(f) then i can't understand, why would we try to execute f(1) at all? And by the way, these "multiple fixed points of function f", are they just (const 1) for n <= 0 and any other values for n > 0? I.e. this if n <= 0 then 1 else undefined is least defined fixed point, but this one: if n <= 1 then 1 else undefined is also fixed point, just not the least defined, and this one: if n <= 0 then 1 else 3 is also a fixed point. Is this correct? Thanks. [1]: https://en.wikibooks.org/wiki/Haskell/Denotational_semantics#Interpretation…

1 0

Prime number test performance on negative integers
by Folsk Pratima 11 Dec '23

11 Dec '23

Please explain why this fails for negative numbers. By fails I mean it starts eating RAM infinitely until either me or OOM kills it. If you replace `m1` definition with the one commented out, the code will fail for positive integers as well, which is very frustrating. import System.Environment isPrime :: Int -> (Bool, String) isPrime n = let ll n = k + 1 : k + 5 : ll (n + 1) where k = 6 * n + 1 l = 2 : 3 : 5 : ll 1 q (i:is) | i * i > n = (True, "it is") | (n `rem` i) == 0 = (False, "divisible by " ++ show i) | otherwise = q is in q l main = getArgs >>= \argv -> let f True = "primal" f False = "not primal" m0 = map (\x -> read x :: Int) argv m1 = m0 --m1 = -- map -- (\x -> -- if x < 0 -- then -x -- else x) -- m0 m2 = map isPrime m1 msg (x, (y0, y1)) = x ++ " is " ++ f y0 ++ " because " ++ y1 in mapM_ putStrLn $ map msg (zip argv m2)

2 5

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