- Beginners - Haskell.org

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

Re: [Haskell-beginners] Beginners Digest, Vol 161, Issue 1
by Michael Turner 12 Dec '21

12 Dec '21

Regards, Michael Turner Executive Director Project Persephone 1-25-33 Takadanobaba Shinjuku-ku Tokyo 169-0075 Mobile: +81 (90) 5203-8682 turner(a)projectpersephone.org Understand - http://www.projectpersephone.org/ Join - http://www.facebook.com/groups/ProjectPersephone/ Donate - http://www.patreon.com/ProjectPersephone Volunteer - https://github.com/ProjectPersephone "Love does not consist in gazing at each other, but in looking outward together in the same direction." -- Antoine de Saint-Exupéry On Sun, Dec 12, 2021 at 8:48 PM <beginners-request(a)haskell.org> wrote: > have another look at > https://hackage.haskell.org/packaggetCallStackgetCallStacke/base-4.16.0.0/d… > <https://hackage.haskell.org/package/base-4.16.0.0/docs/GHC-Stack.html#v:cal…> I'd been looking at that already, over and over. Still not seeing it. But your proposed fix does work. Thank you. > let l = getCallStack callStack > print (length l) > ``` > the `getCallStack` does not return an "IO" value.. And yet it's it's somehow an IO value in "print (length (getCallStack callStack))"? I just don't get this. > On Sun, Dec 12, 2021, 12:58 Michael Turner <michael.eugene.turner(a)gmail.com> > wrote: > > > The following prints 1, as you'd expect: > > ----------------- > > import GHC.Stack > > > > foo :: HasCallStack => IO () > > foo = do > > print (length (getCallStack callStack)) > > > > main = > > foo > > ------------------- > > But when I make it this: > > ... > > l <- getCallStack callStack ; > > print (length l) > > > > I get all this: > > ------------------------------------------ > > ... > > • Couldn't match type ‘[]’ with ‘IO’ > > Expected type: IO ([Char], SrcLoc) > > Actual type: [([Char], SrcLoc)] > > • In a stmt of a 'do' block: l <- getCallStack callStack > > In the expression: > > do l <- getCallStack callStack > > print (length l) > > In an equation for ‘foo’: > > foo > > = do l <- getCallStack callStack > > print (length l) > > | > > 5 | l <- getCallStack callStack ; > > | ^^^^^^^^^^^^^^^^^^^^^^ > > -------------------------------------------- > > > > What am I not seeing? > > > > > > Regards, > > Michael Turner > > Executive Director > > Project Persephone > > 1-25-33 Takadanobaba > > > > Shinjuku-ku Tokyo 169-0075 > > Mobile: +81 (90) 5203-8682 > > turner(a)projectpersephone.org > > > > Understand - http://www.projectpersephone.org/ > > Join - http://www.facebook.com/groups/ProjectPersephone/ > > Donate - http://www.patreon.com/ProjectPersephone > > Volunteer - https://github.com/ProjectPersephone > > > > "Love does not consist in gazing at each other, but in looking outward > > together in the same direction." -- Antoine de Saint-Exupéry

2 3

But I just want a function that returns stack depth!
by Michael Turner 12 Dec '21

12 Dec '21

The following prints 1, as you'd expect: ----------------- import GHC.Stack foo :: HasCallStack => IO () foo = do print (length (getCallStack callStack)) main = foo ------------------- But when I make it this: ... l <- getCallStack callStack ; print (length l) I get all this: ------------------------------------------ ... • Couldn't match type ‘[]’ with ‘IO’ Expected type: IO ([Char], SrcLoc) Actual type: [([Char], SrcLoc)] • In a stmt of a 'do' block: l <- getCallStack callStack In the expression: do l <- getCallStack callStack print (length l) In an equation for ‘foo’: foo = do l <- getCallStack callStack print (length l) | 5 | l <- getCallStack callStack ; | ^^^^^^^^^^^^^^^^^^^^^^ -------------------------------------------- What am I not seeing? Regards, Michael Turner Executive Director Project Persephone 1-25-33 Takadanobaba Shinjuku-ku Tokyo 169-0075 Mobile: +81 (90) 5203-8682 turner(a)projectpersephone.org Understand - http://www.projectpersephone.org/ Join - http://www.facebook.com/groups/ProjectPersephone/ Donate - http://www.patreon.com/ProjectPersephone Volunteer - https://github.com/ProjectPersephone "Love does not consist in gazing at each other, but in looking outward together in the same direction." -- Antoine de Saint-Exupéry

2 1

Looking for training
by Pratap Pachipulusu 20 Oct '21

20 Oct '21

Hello Members, Could you please suggest good haskell resources to start learning from scratch. I would love to be on top of it. Thanks, Pratap P.

5 9