- Beginners - Haskell.org

newEmptyMVar return type
by Velichko Lefterov 06 Jan '21

06 Jan '21

Hello, could someone explain me simple how return-type polymorphism works in the following case: newEmptyMVar :: IO (MVar a) ?

2 2

No ghci return for homemade types
by Lawrence Bottorff 03 Jan '21

03 Jan '21

I've tried this data MyMaybe a = Just a | Nothing maybeHead :: [t] -> MyMaybe t maybeHead [] = Nothing maybeHead (x:_) = Just x and it evaluates fine. But this maybeHead [1,2,3] produces error: : • No instance for (Show (MyMaybe Integer)) : arising from a use of ‘show’ : • In the expression: show (maybeHead [1, 2, 3]) : In an equation for ‘it’: it = show (maybeHead [1, 2, 3]) Similarly, data Color a = Blue a | Green a | Red a myFavoriteColor :: Color Int myFavoriteColor = Green 50 but now I'm stuck. How can I access the "Green 50" inside myFavoriteColor? LB

2 1

Type explanation of foldl?
by Lawrence Bottorff 03 Jan '21

03 Jan '21

I've got this myFoldl f init [] = init myFoldl f init (x:xs) = myFoldl f newInit xs where newInit = f init x which when evaluated gives this for its type > :t myFoldl myFoldl :: (t -> a -> t) -> t -> [a] -> t . . . not totally sure what that all means, e.g., how the t as a generic class is behaving is very mysterious. Obviously, the final result is of type t . . . and that must relate to the incoming argument init, correct? (BTW, does a type declaration like this one reflect in any way the recursion going on?) But then with Prelude foldl I'm really clueless > :t foldl foldl :: Foldable t => (b -> a -> b) -> b -> t a -> b I'm guessing the t is again a generic type of the Foldable class, but then. . . Can someone walk me through this? LB

2 1

Type variables
by Lawrence Bottorff 01 Jan '21

01 Jan '21

I put this into ghci makeTriple :: a -> b -> c -> (a,b,c) makeTriple x y z = (x,y,z) then as expected > :t makeTriple : makeTriple :: a -> b -> c -> (a, b, c) but then on a whim I try this > :t (makeTriple 123 "Hi" 234.0) (makeTriple 123 "Hi" 234.0) :: (Fractional c, Num a) => (a, [Char], c) I retry > :t (123,"Hi",234.0) (123,"Hi",234.0) :: (Fractional c, Num a) => (a, [Char], c) What is this telling me? I'm not experienced enough to decode this. LB

3 2

Lambda calc version of Haskell lambda function
by Lawrence Bottorff 01 Jan '21

01 Jan '21

Here is a function declaration makeAddress :: Int -> String -> String -> (Int, String, String) makeAddress number street town = (number,street,town) and here is a lambda function version makeAddressLambda = (\number -> (\street -> (\town -> (number, street, town)))) How would this lambda version look in lambda calculus? Like this? \number.\street.\town.(number street town) then (\number.\street.\town.(number street town) (123 "Sunny St." "Fergus") (\street.\town.(123 street town) ("Sunny St." "Fergus") (\town.(123 "Sunny St.") ("Fergus") (123 "Sunny St." "Fergus") Not always sure. LB

2 1

OOP exercise with closures
by Lawrence Bottorff 29 Dec '20

29 Dec '20

First, thanks for all the help you've offered. Often enough, it's so much that it takes me time to sift through all the good stuff. Thanks again. Okay, I'm in Lesson 10 of *Get Programming with Haskell * and we're creating an OOP-like world with closures. The first step is a cup object with one attribute, its ounce size. Here's a "constructor" cup :: t1 -> (t1 -> t2) -> t2 cup flOz = \message -> message flOz so this returns upon use > myCup = cup 6 myCup which has "internally" a lambda function (\message -> message) 6 waiting, correct? Now a "method" getOz aCup = aCup (\foz -> foz) creates a closure on the lambda function (\foz -> foz) . So upon calling > getOz myCup 6 I'm guessing myCup (\foz -> foz) was evaluated, but I don't understand how the 6 that went in as the bound variable in the constructor came out again with getOz. As I understand it, the cup constructor creates a closure around the given bound argument flOz -- which is confusing because I thought closures "carried" free variables, not bound variables. Perhaps the getOz lambda function (\foz -> foz) replaces completely the (\message -> message) lambda function? So the constructor could have been written cup flOz = (\message -> message) flOz In any case I'm shaky on how A) cup 6 sets up/stores the 6 in the creation of myCup and then how getOz pops it out again. LB

2 2

Confusion over currying, , lambda, and closures
by Lawrence Bottorff 24 Dec '20

24 Dec '20

I have these three versions of addition addA x y = x + y addB x = \y -> x + y addC = \x -> \y -> x + y and all three add two arguments just fine > addA 2 3 5 > addB 2 3 5 > addC 2 3 5 but I can't see how addB and addC are actually accomplishing this. addA is currying, which I don't fully follow. addC I understand beta reduction-wise (\x -> \y -> x + y) 2 3 (\y -> 2 + y) 3 (2 + 3) 5 but I don't understand addB and what steps are happening currying/beta reduction-wise. Can someone break down the steps with addA and addB? LB

5 4

mconcat
by PICCA Frederic-Emmanuel 24 Dec '20

24 Dec '20

Hello, I have a monoid and I would like to know if there is a way to do the concatenation in parallele ? the mappend method takes time for my type. thanks for you help. Frederic

1 0

Another currying and lambda question
by Lawrence Bottorff 22 Dec '20

22 Dec '20

In *Learn You... <http://learnyouahaskell.com/higher-order-functions> *I'm seeing this flipA :: (a -> b -> c) -> b -> a -> c flipA f x y = f y x and this flipB :: (a -> b -> c) -> b -> a -> c flipB f = \x y -> f y x What is it specifically about currying that makes flipA possible? Also, with flipB, could someone explain the beta reduction? It looks like f is not being acted on, just passed along, Would it look more like this in lambda calculus? (\x \y -> f y x) then (\x \y -> f y x) g a b gives g b a ? LB

2 2

Lambda expression currying
by Lawrence Bottorff 22 Dec '20

22 Dec '20

Here's something from *Learn You... * Lambdas are normally surrounded by parentheses unless we mean for them to extend all the way to the right. Here's something interesting: due to the way functions are curried by default, these two are equivalent: addThree :: (Num a) => a -> a -> a -> a addThree x y z = x + y + z addThree :: (Num a) => a -> a -> a -> a addThree = \x -> \y -> \z -> x + y + z If we define a function like this, it's obvious why the type declaration is what it is. There are three ->'s in both the type declaration and the equation. But of course, the first way to write functions is far more readable, the second one is pretty much a gimmick to illustrate currying. So with the lambda version how exactly is the currying taking place? I understand something like this doubleDouble x = (\x -> x*2) (2 * x) So with beta reduction we have (2*x)*2, then plug in the argument. And with this overwrite x = (\x -> (\x -> (\x -> x) 4) 3) 2 which gives (\x -> (\x -> 4) 3) 2 (\x -> 4) 2 4 But how is the beta reduction happening with addThree? BTW, I flunked lambda calculus in Kindergarten. LB

2 2