December 2020 - Beginners

OOP exercise with closures
by Lawrence Bottorff 30 Dec '20

30 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 23 Dec '20

23 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 23 Dec '20

23 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

Problem with minimax with alpha beta pruning
by Maxim Frolov 22 Dec '20

22 Dec '20

Hi All, I am new to Haskell and got stuck while experimenting with minimax algorithm (tic-tac-toe game). Just for learning I am trying to avoid external modules and use only the standard Prelude library. Here is the code snippet: type Pos = (Int,Int) -- Players are O (minimizing) and X (maximizing), B is for the draw (blank), I and J are used for -INF and +INF respectively data Player = I | O | B | X | J deriving (Eq, Ord, Show) type Grid = [(Pos,Player)] data Tree a = Node a [Tree a] deriving Show minimax :: Player -> Player -> Tree Grid -> Tree (Grid, Player) minimax _ _ (Node g []) | wins X g = Node (g,X) [] | wins O g = Node (g,O) [] | otherwise = Node (g,B) [] minimax a b (Node g ts) | turn g == X = let ts' = [minimax alpha b t | t <- ts, alpha < b] ps = [p | Node (_,p) _ <- ts'] alpha = maximum (a:ps) in Node (g, alpha) ts' | turn g == O = let ts' = [minimax a beta t | t <- ts, a < beta] ps = [p | Node (_,p) _ <- ts'] beta = minimum (b:ps) in Node (g, beta) ts' The function call is like: minimax I J tree It looks like I got a recursion loop. Could someone advise how to approach the problem? Thank you, Max

2 2

map type explanation
by Lawrence Bottorff 21 Dec '20

21 Dec '20

I'm looking at this ghci> :type map map :: (a -> b) -> [a] -> [b] and wondering what the (a -> b) part is about. map takes a function and applies it to an incoming list. Good. Understood. I'm guessing that the whole Haskell type declaration idea is based on currying, and I do understand how the (a -> b) part "takes" an incoming list, [a] and produces the [b] output. Also, I don't understand a and b very well either. Typically, a is just a generic variable, then b is another generic variable not necessarily the same as a. But how are they being used in this type declaration? LB

8 10

bayes-monad package
by Leduin José Cuenca Macas 18 Dec '20

18 Dec '20

Dear all, I want to know if there exists a free access project that uses the bayes-monad package. The purpose is to use this project as an end-course task. Kind regards. *Leduin José Cuenca Macas* *Student | Estudiante* Tel. (+593) 991 618 273

2 1

1=2
by M Douglas McIlroy 16 Dec '20

16 Dec '20

ghc and ghci 8.6.5 accept 1=2 at top level. It seems to have no effect. What does it mean?

4 4

Nested folds
by Pietro Grandinetti 14 Dec '20

14 Dec '20

Hello, I have a piece of code to represents Sentences, Paragraphs and the Content of an article. I added functions to count the words, code below. My questions: 1- Are these functions idiomatic? 2- Is this an efficient way to do the computation? 3- In different languages, I could (and would) give the same name `wordCount` to the three functions, because the type of the input would clarify the usage. But here GHC throws an error. What's the most idiomatic way to do this in Haskell? type Sentence = String type Paragraph = [Sentence] type Content = [Paragraph] sentWordCount :: Sentence -> Int sentWordCount = length . words parWordCount :: Paragraph -> Int parWordCount = foldr ((+) . sentWordCount) 0 contWordCount :: Content -> Int contWordCount = foldr ((+) . parWordCount) 0 I also have two more practical questions on the following two functions: makeSentence :: String -> Sentence makeSentence x = x::Sentence sentCharCount :: Sentence -> Int sentCharCount x = length $ filter (/= ' ') x 4- About `makeSentence` -- does it make sense to write a function like that just to encapsulate the String type? 5- About `sentCharCount` -- I cannot take the argument x off, the compilator complains. What's the reason? Thanks, -P

2 3