- Beginners - Haskell.org

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

Invoking ghci with hackage modules
by Lists0 16 Jun '22

16 Jun '22

Hi all, a very basic question, that I cannot solve alone: How do I load modules from hackage into ghci ? Say, I have a module arrows.hs : {-# LANGUAGE Arrows #-} module Main where import Control.Arrow import Control.Monad import qualified Control.Category as Cat import Data.List import Data.Maybe import System.Random I get the error in ghci: % ghci arrows.hs GHCi, version 8.10.6: https://www.haskell.org/ghc/ :? for help [1 of 1] Compiling Main ( arrows.hs, interpreted ) arrows.hs:9:1: error: Could not find module ‘System.Random’ Use -v (or `:set -v` in ghci) to see a list of the files searched for. | 9 | import System.Random | ^^^^^^^^^^^^^^^^^^^^ Failed, no modules loaded. Prelude> System.Random is in the package "random" from hackage, where the other modules are in the package base. I cannot find a solution in the doku that works :-( Thanks for help!

4 3

Utrecht Summer School on Advanced Functional Programming 2022
by Swierstra, W.S. (Wouter) 08 Apr '22

08 Apr '22

# Call for Participation SUMMER SCHOOL ON ADVANCED FUNCTIONAL PROGRAMMING Utrecht, the Netherlands, 04 July – 08 July 2022 http://www.afp.school ## ABOUT The Advanced Functional Programming summer school has been running for more than ten years. We aim to educate aspiring Haskell programmers beyond the basic material covered by many textbooks. After running remotely for the past two years, we're thrilled to announce that this year's edition will take place on site in Utrecht. We are monitoring the pandemic closely - and will make contingency plans if we cannot meet in person; at the moment, we do not have plans for remote participation. The lectures will cover several more advanced topics regarding the theory and practice of Haskell programming, including topics such as: * lambda calculus; * monads and monad transformers; * lazy evaluation; * generalized algebraic data types; * type families and type-level programming; * concurrency and parallelism. The summer school consists of a mix of lectures, labs, and a busy social program. ## LECTURERS * Gabriele Keller * Trevor McDonell * Wouter Swierstra ## 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 Soft registration deadline: 24 June, 2022 School: 04 July – 08 July 2022 ## COSTS 750 euro - Profession registration only 250 euro - Student registration fee 200 euro - Housing fee We will charge a registration fee of 750 euros (or 250 euros for students) to cover our expenses. 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://www.afp.school

1 0

Evaluation oddity
by Torsten Otto 06 Feb '22

06 Feb '22

Hi all, maybe one of you sees a difference, I sure don’t… The full code for this is below. When I call *Main> diffieH 23 16 20 13 and use the result in *Main> encipher "abc" 13 „nop" I get the letters to be expected. However, when I combine these into > start text p a b = encipher text (diffieH p a b) *Main> start "abc" 23 16 20 „efg" the result changes. Any hints are most welcome. Thank you and regards Torsten > import Data.Char > diffieH p a b = (b ^ a) `mod` p > number2letter number = chr (number + 96) > letter2number letter = (ord letter) - 96 > start text p a b = encipher text (diffieH p a b) > encipher [] _ = [] > encipher (b:rest) key = (number2letter (((letter2number b)+key) `mod` 26)) : (encipher rest key)

2 1

Parsing a file
by Roger Mason 27 Jan '22

27 Jan '22

Hello, Warning: long post. I've worked my way through various parsing tutorials using either Parsec or ReadP. I reached a point where I need to try parsing one of the types of file for which I'm writing the parser. I have written parsers for various parts of this file: eqatoms.out: ====================================================== Species : 1 (Si) atom 1 is equivalent to atom(s) 1 2 3 atom 2 is equivalent to atom(s) 1 2 3 atom 3 is equivalent to atom(s) 1 2 3 Species : 2 (O) atom 1 is equivalent to atom(s) 1 2 3 4 5 6 atom 2 is equivalent to atom(s) 1 2 3 4 5 6 atom 3 is equivalent to atom(s) 1 2 3 4 5 6 atom 4 is equivalent to atom(s) 1 2 3 4 5 6 atom 5 is equivalent to atom(s) 1 2 3 4 5 6 atom 6 is equivalent to atom(s) 1 2 3 4 5 6 ====================================================== These are my imports: ====================================================== import qualified Text.Parsec as Parsec import Text.Parsec ((<?>)) import Control.Applicative import Control.Monad.Identity (Identity) ====================================================== These are my parsers: ====================================================== :{ species :: Parsec.Parsec String () (String,String) species = do --Parsec.char 'S' Parsec.string "Species" Parsec.spaces Parsec.char ':' Parsec.spaces digits <- Parsec.many1 Parsec.digit Parsec.spaces Parsec.char '(' id <- Parsec.many1 Parsec.letter return (id,digits) :} :{ atom = do Parsec.spaces Parsec.string "atom" Parsec.spaces digits <- Parsec.digit return digits :} :{ equivalents = do Parsec.spaces digits <- Parsec.digit return digits :} ====================================================== Some simple tests: ====================================================== src = "oops" Parsec.parse species src "Species : 1 (Si)" Right ("Si","1") src = "Parsing_File/eqatoms.out" Parsec.parse atom src "atom 5 is equivalent to atom(s)" Right '5' src = "Parsing_File/eqatoms.out" Parsec.parse (Parsec.many1 equivalents) src " 1 2 3 4 5 6" : Right "123456" ====================================================== So, the individual parsers work as intended. However, parsing an actual file does not work. I define a function to return the file contents: ====================================================== :{ input = do eqatoms <- readFile "Parsing_File/eqatoms.out" return eqatoms :} ====================================================== A test shows that my reader works: ====================================================== input : Species : 1 (Si)\n atom 1 is equivalent to atom(s)\n 1 2 3\n atom 2 is equivalent to atom(s)\n 1 2 3\n atom 3 is equivalent to atom(s)\n 1 2 3\n\nSpecies : 2 (O)\n atom 1 is equivalent to atom(s)\n 1 2 3 4 5 6\n atom 2 is equivalent to atom(s)\n 1 2 3 4 5 6\n atom 3 is equivalent to atom(s)\n 1 2 3 4 5 6\n atom 4 is equivalent to atom(s)\n 1 2 3 4 5 6\n atom 5 is equivalent to atom(s)\n 1 2 3 4 5 6\n atom 6 is equivalent to atom(s)\n 1 2 3 4 5 6\n ====================================================== I attempt to parse the input: ====================================================== :{ main = do eqatoms <- readFile "Parsing_File/eqatoms.out" Parsec.parse species "test species" eqatoms return :} Prelude Parsec Text.Parsec Control.Applicative Control.Monad.Identity| Prelude Parsec Text.Parsec Control.Applicative Control.Monad.Identity| Prelude Parsec Text.Parsec Control.Applicative Control.Monad.Identity| Prelude Parsec Text.Parsec Control.Applicative Control.Monad.Identity| Prelude Parsec Text.Parsec Control.Applicative Control.Monad.Identity| <interactive>:250:3: error: ,* Couldn't match type `Either Parsec.ParseError' with `IO' Expected type: IO (String, String) Actual type: Either Parsec.ParseError (String, String) ,* In a stmt of a 'do' block: Parsec.parse species "test species" eqatoms In the expression: do eqatoms <- readFile "Parsing_File/eqatoms.out" Parsec.parse species "test species" eqatoms return In an equation for `main': main = do eqatoms <- readFile "Parsing_File/eqatoms.out" Parsec.parse species "test species" eqatoms return <interactive>:251:3: error: ,* Couldn't match expected type `IO b' with actual type `a0 -> m0 a0' ,* Probable cause: `return' is applied to too few arguments In a stmt of a 'do' block: return In the expression: do eqatoms <- readFile "Parsing_File/eqatoms.out" Parsec.parse species "test species" eqatoms return In an equation for `main': main = do eqatoms <- readFile "Parsing_File/eqatoms.out" Parsec.parse species "test species" eqatoms return ,* Relevant bindings include main :: IO b (bound at <interactive>:248:3) ====================================================== Can someone please help me to get this to work? Thanks for reading to the end of this very long post. Roger

3 6

Coercing existential according to type-level Maybe
by Dmitriy Matrosov 30 Dec '21

30 Dec '21

Hi. I've tried to write a function to coerce existential value according to type stored in type-level 'Maybe' (i.e. 'Just or 'Nothing). > {-# LANGUAGE DataKinds #-} > {-# LANGUAGE RankNTypes #-} > {-# LANGUAGE KindSignatures #-} > {-# LANGUAGE PolyKinds #-} > {-# LANGUAGE TypeFamilies #-} > {-# LANGUAGE GADTs #-} > > import Data.Kind > import Data.Proxy > import Unsafe.Coerce > > class FromTypeMaybe k where > type ToType k > fromTypeMaybe :: (a -> ToType k) -> Proxy k -> a -> Maybe (ToType k) > > instance forall (t :: Type). FromTypeMaybe ('Nothing :: Maybe t) where > type ToType 'Nothing = t > fromTypeMaybe f _ x = Nothing > > instance forall (t :: Type). FromTypeMaybe ('Just t :: Maybe Type) where > type ToType ('Just t) = t > fromTypeMaybe f _ x = Just (f x) > > data Any where > Any :: a -> Any > > unAny :: Any -> t > unAny (Any x) = unsafeCoerce x This works as far as i can see *Main> fromTypeMaybe unAny (Proxy @('Just Int)) (Any 3) Just 3 *Main> fromTypeMaybe unAny (Proxy @'Nothing) undefined Nothing but i don't understand how 'Nothing instance works: type kind kind? vvv vvvvvv vvv instance forall (t :: Type). FromTypeMaybe ('Nothing :: Maybe t) where type ToType 'Nothing = t ^^^ type (in case alignment breaks: variable 't' in forall is type-variable with kind 'Type', but in "Maybe t" in instance head it's used as kind-variable. And then in associated type-family the same variable 't' is used as type-variable again). If i try to write "'Nothing"'s kind as 'Maybe Type' (in the same manner as 'Just has) instance forall (t :: Type). FromTypeMaybe ('Nothing :: Maybe Type) where i get an error: 1.lhs:21:3: error: • Type variable ‘t’ is mentioned in the RHS, but not bound on the LHS of the family instance • In the type instance declaration for ‘ToType’ In the instance declaration for ‘FromTypeMaybe ('Nothing :: Maybe Type)’ | 21 | > instance forall (t :: Type). FromTypeMaybe ('Nothing :: Maybe Type) where | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^... Well, i'm not sure, that understand why 'forall' in instance head may not be used as family's LHS, but.. that's probably ok. On the other hand, if i try to write 'Just instance using type-variable 't' as kind-variable (in the same manner as 'Nothing has): instance forall (t :: Type). FromTypeMaybe ('Just t :: Maybe t) where i get an error too: 1.lhs:25:47: error: • Expected kind ‘Maybe t’, but ‘'Just t’ has kind ‘Maybe *’ • In the first argument of ‘FromTypeMaybe’, namely ‘('Just t :: Maybe t)’ In the instance declaration for ‘FromTypeMaybe ('Just t :: Maybe t)’ | 25 | > instance forall (t :: Type). FromTypeMaybe ('Just t :: Maybe t) where Well, that's also probably expected, because though i've declared type-variable 't' with kind 'Type' in forall, due to 'DataKinds' extension type 't' is also promoted to kind 't' and, thus, by using ('Just t :: Maybe t) i say, that ('Just t) should have kind 'Maybe t', not 'Maybe Type', which it really has. But if that's so, how working 'Nothing instance instance forall (t :: Type). FromTypeMaybe ('Nothing :: Maybe t) where may work at all? It has the same problem as 'Just instance above: type-variable 't' is promoted to kind 't' and 'Nothing will have kind 'Maybe t' instead of 'Maybe Type' ?

2 1

Confusing Show/print error
by Galaxy Being 28 Dec '21

28 Dec '21

I've got this import Data.Tuple fswp :: (a, b) -> (b, a) fswp = Data.Tuple.swap and get this • No instance for (Show ((a0, b0) -> (b0, a0))) arising from a use of ‘print’ (maybe you haven't applied a function to enough arguments?) • In a stmt of an interactive GHCi command: print it Not sure why or what to do to correct it. ⨽ Lawrence Bottorff Grand Marais, MN, USA borgauf(a)gmail.com

9 10

Non-exhaustive patterns
by Galaxy Being 12 Dec '21

12 Dec '21

This code myTakePM :: Int -> [a] -> [a] myTakePM 0 _ = [] myTakePM n (x:xs) = x : myTakePM (n-1) xs is bad because it allows myTakePM 4 [1,2,3] [1,2,3*** Exception: <interactive>:(395,1)-(396,41): Non-exhaustive patterns in function myTakePM I knew it would not work, but why is it calling this essentially a partial function? How does it know this? Again, I expected an error, but what is this Non-exhaustive patterns in function myTakePM saying? Or, said another way, what exactly is non-exhaustive about this? -- ⨽ Lawrence Bottorff Grand Marais, MN, USA borgauf(a)gmail.com

3 2