Uncle Vogel Learns You a Haskell

Vogel612

Mar 1, 2018 23:10

notational aside: I'll be using haskell type notation for this, because that's what I'm comfy with....

RubberDuck

Comfortable with Haskell.....

this

@RubberDuck Gotcha. I can imagine it'll help eliminate most dumb configurations. That said, ti was painful years when we got a server and it turn out it was all the wrong.

Vogel612

we can denote the types of the arguments a function f takes (and the type it returns) by using something like the following

f :: a -> b -> c -> d
f a b c = d

in a more "traditional" notation, that would be:

this

Check: -> => should call this function?

(I know nothing about Haskell)

Vogel612

function f(a a, b b, c c) As d
   return d

this

Mar 1, 2018 23:12

ah

sorry, one more thing to clarify

in math, we have notations like f(x)

or maybe f(x, y)

wouldn't it have been d = f(a, b, c) ?

Duga

[rubberduck-vba/Rubberduck] retailcoder published prerelease Rubberduck-v2.1.2.2912

[rubberduck-vba/Rubberduck] retailcoder created tag Rubberduck-v2.1.2.2912

Vogel612

@this if you'd go for math notation... yes

that's exactly what this boils down to.

Duga

[rubberduck-vba/Rubberduck] build for commit b20a7eb2 on next: AppVeyor build succeeded

Vogel612

now let's talk about delegates.

Duga

[rubberduck-vba/Rubberduck] build for commit b20a7eb2 on next: 55.76% (target 0%)

Vogel612

Mar 1, 2018 23:14

Consider a function: f :: x -> y (f(someX) = someY)

this

I guess what I'm not understanding yet why Haskell would write the function so that the last term is the return, and the terms in middle are the parameters --- do the parameters get passed into the function that they are called?

Vogel612

we can pass that function as an argument to another function

@this you're looking at the typedefinition there

this

oooh

IvenBach

@Vogel612 This is the type definition?

RubberDuck

Where each argument is a function that takes a single argument.

this

Mar 1, 2018 23:15

so I'm defining the function, parameters and the return type in that first statement.

RubberDuck

Yes

Vogel612

fun :: a -> b -> c -> d
fun someA someB someC = someD
----
Sub Fun(someA As A, someB As B, someC As C) As D
    Fun = someD
End Sub

this

OK

Vogel612

cool. back to how we can pass around functions.

let's say we have a function f.

f :: x -> y
f x = x^2

now if we want to use this as an argument in another function, we can denote that by enclosing the type in parens.

this

checking --- why isn't it written y = x^2

Vogel612

Mar 1, 2018 23:17

foo :: (x -> y) -> z

this

(i'm expecting the y to be the return type)

Vogel612

@this note that in the first line, x and y are type variables

in the second, they are values

this

OK.

Vogel612

might be better to use actual types for now....

f :: Double -> Double
f x = x^2

this

ah i see

so we're saying the function f will take a type of double, then return a double

then we define the function

Vogel612

Mar 1, 2018 23:18

correct

this

OK with you now

RubberDuck

Bingo

Vogel612

now we can pass f to another function. Something like map

... crap I need to introduce lists before introducing map...

this

well, lisps are lists. :)

Vogel612

Lists in haskell are denoted by square brackets around their typename.

RubberDuck

Mar 1, 2018 23:19

... slower. Do a pow4

Vogel612

good idea.

okay. so we want a pow4

this

pow4 => raised to the 4th power, yes?

Vogel612

since we want to express that in terms of our f, it has the following signature:

pow4 :: (Double -> Double) -> Double -> Double

we can define it as follows:

this

is (Double -> Double) an anonymous function type?

RubberDuck

Essentially. Yes.

Vogel612

Mar 1, 2018 23:22

pow4 square x = (square x) * (square x)

this

Hmm. interesting.

let me work that one out.

we have defined the body of the square x

that's the (square x) * (square x)

M.Doerner

Just for context -> is right associative.

Duga

[rubberduck-vba/Rubberduck] build for commit 68dfa8ec on unknown branch: AppVeyor build succeeded

Vogel612

no that's the body of pow4. We don't even know the body of square right now, because square is a variable

Duga

[rubberduck-vba/Rubberduck] [codecov[bot]](github.com/apps/codecov) commented on pull request #3813: Make project declarations disposable

> # [Codecov](https://codecov.io/gh/rubberduck-vba/Rubberduck/pull/3813?src=pr&el=h1) Report
> Merging [#3813](https://codecov.io/gh/rubberduck-vba/Rubberduck/pull/3813?src=pr&el=desc) into [next](https://codecov.io/gh/rubberduck-vba/Rubberduck/commit/b20a7eb2dbd62b6b48c05780a44671e16bcc0c48?src=pr&el=desc) will **increase** coverage by `<.01%`.
> The diff coverage is `51.43%`.

```diff
@@ Coverage Diff @@
## next #3813 +/- ##
=======================

[rubberduck-vba/Rubberduck] build for commit 68dfa8ec on unknown branch: 55.76% (target 0%)

this

Mar 1, 2018 23:24

that's the problem, actually. I was assuming that square x got defined because it was recursive

so I guess Haskell let you forward-declare the function square

RubberDuck

@this you’re familiar with math, right? This is function composition.

f(g(x))

this

not that type of math, sorry, no. Last time I did math (years and years) I got as far as differntial equations and some fourier series but I've forgotten too much of it.

ah yes

Vogel612

yea. assuming that square is what it says on the tin, we can write pow4 as follows:

pow4 square x = square (square x)

this

I honestly don't remember having discussed stuff like right associative.

Right but we still do have to define the square in the haskell?

e.g. square x * x

Vogel612

for now it's just a variable

M.Doerner

Mar 1, 2018 23:27

The confusing thing is that Haskell does not have the parentheses.

Vogel612

what you have there is something like this in C#:

double pow4(Func<double, double> square, double x)
{
    return square(square(x));
}

M.Doerner

What I meant is that a -> b -> c -> d is the same as a -> (b -> (c -> d)).

IvenBach

@Vogel612 I feel like a chimp that's found the banana in the forest. I understand and follow!

Vogel612

@M.Doerner shh, you're spoiling the surprise

this

OK, but when you call the pow4, you do have to pass in the function definition.

Vogel612

Mar 1, 2018 23:29

well... yes.

this

so I'm still thinkin that in Haskell I have to actually define what a square is

M.Doerner

And in general not the same as (a -> b) -> c -> d.

Vogel612

let's rename some of these things that we got:

M.Doerner

night

Vogel612

the old f that we had. Let's call that square

this

Mar 1, 2018 23:30

night

Vogel612

the pow4 that we had, let's call that twice

writing it down, we have the following now:

square :: Double -> Double
square x = x * x

twice :: (Double -> Double) -> Double -> Double
twice f x = f(f(x))

I miss typevariables...

okay, now to the mindboggling part.

this

right.

this is making sense now

Vogel612

given these two function definitions: how would you write a function pow4?

this

wait wait

didn't we already have it?

that is, the twice is equivalent to pow4?

Vogel612

hum. no. That's a bit ... my fault

because... we have no clue what f is...

this

Mar 1, 2018 23:34

right.

Vogel612

add5 x = x + 5
add10 x = twice add5 x

this

so I have to define f I assume

SlowLearner

lol I have no clue what the f is

Vogel612

no. you have to pass it as argument

this

wait wait, so fis a type?

Vogel612

Mar 1, 2018 23:35

no. it's a variable, that just happens to actually contain a function

this

drat

ok so f is equivalent to C#'s Func<...>

Vogel612

7 mins ago, by Vogel612

double pow4(Func<double, double> square, double x)
{
    return square(square(x));
}

this

which will return x

right

Vogel612

4 mins ago, by Vogel612

given these two function definitions: how would you write a function pow4?

this

just to make sure I'm following among....

f has the type of (Double -> Double)

Vogel612

Mar 1, 2018 23:37

correct

this

which is why we can then write f(f(x))

Vogel612

also correct

this

which amounts to "run the function f on the x, take the result then apply it to function f again"

RubberDuck

yup

IvenBach

@SlowLearner You're not entirely alone. I'm sorta following. But I have to think about it really hard for it to make sense.

Vogel612

Mar 1, 2018 23:38

that's where the name twice came from

this

Furthermore -

RubberDuck

Just as a refresher.
https://chat.stackexchange.com/transcript/message/43158183#43158183

this

because we have twice :: (Double -> Double) -> Double -> Double

the 3rd Double is the input

Vogel612

yes

this

that's what we've been using as the x in the body

SlowLearner

Mar 1, 2018 23:39

I'll be bookmarking this, need to do some work

Vogel612

fully correct

IvenBach

This tweaks my brain more than a tad.

this

square :: Double -> Double
square x = x * x

twice :: (Double -> Double) -> Double -> Double
twice f x = f(f(x))

pow4 :: twice -> Double -> Double
pow4 x = twice(square(x))

?

Vogel612

good try, but not quite

square(x) returns a Double

twice expects a Func<Double, Double> as it's first argument...

this

I see

wait wait

RubberDuck

Mar 1, 2018 23:43

=)

this

can't i say that square is a Func<double, double>

RubberDuck

More than just say it. It is.

Vogel612

@IvenBach BrainBreaker.hs WARNING, contains major spoilers

this

not looking

pow4 :: twice(square) -> Double -> Double

pow4 x = twice(square(x))

?

Vogel612

now you're mixing types with variables...

IvenBach

Mar 1, 2018 23:45

I looked but aren't trying hard enough to cumprehendrize... Brn mltng fm hrd thkng...

this

ah right.

Vogel612

actually you did that before as well ...

this

ok, so recaping for myself....

Vogel612

it's not really much help, but pow4 :: Double -> Double

this

i'm declaring a new type square :: Double -> Double

Vogel612

Mar 1, 2018 23:46

I'll interject when it's wrong, okay?

this

OK.

I then define the body of the function type

which is the square x = x * x

Just to be sure, the first term on the left side represents the result, which corresponds to the last argument from the function type definition.

Vogel612

no

this

actually the second term (the first x )

Vogel612

the left side is the function name, followed by the argument list.

this

rephrasing a bit more --- the x on the left-side will have the type of the last term in the definition.

Vogel612

Mar 1, 2018 23:48

the = is basically the opening brace, return is implicit

this

then i do not understand why we write square x to the left

Vogel612

that's part of the "method header"

this

why not simply square = x * x

what is the significance of the x to LHS of the =?

Duga

[rubberduck-vba/Rubberduck] rubberduck203 commented on issue #3755: Add the Ribbon XML files under source control

> I'm assuming these aren't exported along with the source code when using the "Export All" feature?
We've remove git integration (#3758), but the export feature is still there.

Would you like us to reword this request to "Export all exports Ribbon XML files"?

Vogel612

foo :: TypeArgument1 -> TypeArgument2 -> TypeResult
foo bar baz = something
---
TypeResult foo(TypeArgument1 bar, TypeArgument2 baz) {
    return something;
}

Duga

Mar 1, 2018 23:51

[rubberduck-vba/Rubberduck] rubberduck203 closed issue #3726: Crash when trying to create or open repository in Source Control

Vogel612

@this because then x is not defined

Duga

[rubberduck-vba/Rubberduck] rubberduck203 commented on issue #3726: Crash when trying to create or open repository in Source Control

> Please see #3758.

Vogel612

@this x on the LHS is the parameter declaration

this

Confirming.... if I define: bar :: foo1 -> foo2 -> foo3 -> foo4 -> foo5

that's 5 different types

and therefore in the definition, i must assign names for each parameter

so therefore bar parameter1 parameter2 parameter3 parameter4 = <body of the function>

?

Vogel612

not quite... foo5 is the return type

this

Mar 1, 2018 23:53

oops

Duga

[rubberduck-vba/Rubberduck] rubberduck203 commented on issue #3710: "Untracked files" needs "Include all" button

> #3758

this

better?

Vogel612

@this let's say yes for now.

Duga

[rubberduck-vba/Rubberduck] rubberduck203 closed issue #3710: "Untracked files" needs "Include all" button

this

ok.

Vogel612

Mar 1, 2018 23:53

@this yes, better

this

point being the return type is implicit

Vogel612

no it's not. it's foo5

Duga

[rubberduck-vba/Rubberduck] rubberduck203 closed issue #3531: cannot use source control

[rubberduck-vba/Rubberduck] rubberduck203 commented on issue #3531: cannot use source control

> Please see #3758.

this

i was referring to the definition, not the declaration

Duga

[rubberduck-vba/Rubberduck] rubberduck203 commented on issue #3481: Failed to clone remote repository: Request failed with status code 403

> Please see #3758

Vogel612

Mar 1, 2018 23:55

I'm pretty sure that the words you use are wrong, but you mean the right thing, then

Duga

[rubberduck-vba/Rubberduck] rubberduck203 closed issue #3481: Failed to clone remote repository: Request failed with status code 403

this

OK

ok, back to the pow4 project.

concept check

square :: Double -> Double
square x = x * x

therefore, the first x is the actual name of the variable that represents the input Double

Vogel612

:+1:

this

Then the body to RHS of the = tells what we will do with the named variables

Duga

[rubberduck-vba/Rubberduck] rubberduck203 commented on issue #3392: Support the MS SCC API

Vogel612

Mar 1, 2018 23:56

yes

Duga

> Gagh! This is very much what I imagined early on....
Oh well. That is life.

We decided in #3758 to remove the feature.

this

the = was throwing me off here. Good to get that clarified.

RubberDuck

It's kind of like this c# lambda.

square(x) => x * x

In Haskell.
square x = x * x

this

yeah

ok, just to confirm -

is it legal to use terms like so....

Vogel612

@RubberDuck let's make this a syntactically correct var square = (x => x * x);

this

Mar 1, 2018 23:59

pow4 :: twice -> Double -> Double

e.g. I used the twice as a type here

Vogel612

@this no, that doesn't work

twice is not a type

it's a name

this

so even though I've defined twice :: (Double -> Double) -> Double -> Double

which is a function

I can't use it like a type,.

Vogel612

these function definitions are basically constants.

this

OK,

Duga

RELOAD!

[Hosch250/CheckersTreasury] 1 commit. 108 additions. 1194 deletions.

[rubberduck-vba/Rubberduck] 12 commits. 3 opened issues. 6 closed issues. 38 issue comments. 1178 additions. 1038 deletions.

[rubberduck-vba/Rubberduck] rubberduck203 commented on issue #3222: Use folders in source control

> @retailcoder still seems like a valid feature request, even in light of #3758. Thoughts?

Vogel612

Mar 2, 2018 00:01

you can't say public double pow4(twice f, double x), you'd theoretically need a typeof

this

hmm i'm going to feel silly if that's right but does that imply that I shold have written pow4 like so.... pow4 :: ((Double -> Double) -> Double) -> Double

aw! I need to go now. :( I really want to solve. But I must go now. #IWillBeRightBack

Vogel612

@this well, that would match more closely the definition of what you tried to express, yes

one possible valid definition of pow4 is the following:

pow4 :: Double -> Double
pow4 x = x * x * x * x

but that'd be boring and not really functional.

let's try if we can simplify this.

something a bit simpler would be the following:

pow4 x = (square(x)) * (square(x))

and here's where I leave you, because I have a reading date with my GF and I'm pretty sure with some thought you should be able to connect the remaining dots

VBA Rubberducking

Participants