The Nineteenth Byte

DLosc

00:14

Aight, so is there someone here who can learn us a Haskell for great good?

If not, I can teach BitCycle or tinylisp.

user

Perhaps @WheatWizard?

Nitrodon

When is LYAL?

DLosc

~~Now~~ as soon as we decide on a language

Do you know enough Haskell to give a basic introduction to the language?

Bgil Midol

00:32

@DLosc a little bit, but only in the repl

lyxal

@Nitrodon judging by the clock, I'd say now o'clock

see?

Nitrodon

I have yet to create any "real" programs in Haskell.

Bgil Midol

^

Unrelated String

i have the strangest feeling that this exact conversation has happened twice before

DLosc

@UnrelatedString Do you volunteer as tribute? :P I see you've written some Haskell answers.

Unrelated String

00:43

probably going to hit the gym in like 15 minutes but i could try to kick things off before then

i'm also actually terrible at haskell but my grasp on the basics is strong enough

emanresu A

The only time I've ever used Haskell is to try and find holes in RTO's security

(Don't worry, I failed)

Unrelated String

the stuff i'm bad at usually isn't relevant to golf so guess i'll look at some previous lyals to see how it makes sense to start off

DLosc

Cool cool

Aiden Chow

@UnrelatedString i think u should start with what haskell actually is (what type of programming language is it, what makes it unique)

DLosc

Welcome to the fifteenth Learn You A Lang for Great Good! Today, we'll be learning Haskell, a polymorphically statically typed, lazy, purely functional language. During the event, feel free to post CMCs to practice Haskell, ask questions about the language, and so on.

12

Unrelated String

00:49

haskell is uhh
purely functional, statically typed, lazily evaluated, and very cool™

Aiden Chow

ok dont know what half of that means but thats very cool

DLosc

@AidenChow See also

emanresu A

@RadvylfPrograms ^^^^ Pin plz

Unrelated String

to start things off it's one of the few languages that has syntax for anonymous functions where it's not golfier to submit them, so a function definition is written as so:

add x y = x + y

this is a terrible example, which i have chosen for several reasons

note that the left hand side represents the syntax with which you would call add, i.e. to add 1 and 2 you would use add 1 2

New Posts

0

Q: Implement a very simple ALU using only NAND gates

Note: This challenge was inspired by Joe Z's many excellent questions surrounding NAND golfing. Description Your goal in this challenge, should you choose to accept it, is to implement a very simple ALU using just NAND gates. The ALU can only perform the the following four operations: 00, meanin...

Unrelated String

00:55

which is equivalent to (add 1) 2, because function application is effectively an operator (and specifically the operator with the tightest precedence)

Aiden Chow

@UnrelatedString what, could you explain what (add 1) 2 means in layman terms, i dont really get that

isnt add taking two arguments, why its one over here

Unrelated String

functions are by default curried: add has type (Num a) => a -> a -> a, and don't worry about the (Num a) => bit for now but this means that add 1 is also a function (Num a) => a -> a that takes some number and increments it

Aiden Chow

what is curried function

im a bit of a noob at programming as you can tell

OldSandboxPosts

Sandbox posts last active a week ago: Reveal all clues of Black Box, Randomly Rounding, Social distance the graph

Unrelated String

and what makes that example terrible is that there's a much, much shorter way to do the exact same thing:

add = (+)

DLosc

01:01

@AidenChow Basically it means that instead of passing multiple arguments to a function, you pass them one at a time. See also Wikipedia.

Unrelated String

since functions are simply values

Nitrodon

A curried function means that (+) is a function that takes one variable and returns a function which takes another variable.

DLosc

My main Haskell question is: Say I write a function that returns an integer (or list of integers, or whatever). How do I write a main program that calls the function and outputs the result?

Nitrodon

so add 3 (or (3+)) is a function that adds 3 to its input.

Unrelated String

full prgrams in haskell define a value main :: IO ()

so to print the result of a function call you would most likely use print :: (Show a) => a -> IO ()

Nitrodon

01:03

like this

Unrelated String

as so

Aiden Chow

@UnrelatedString so all of that stuff isnt counted in the byte count right

Newly Featured Posts

6

Q: Complex permutation

Given an array of integers as input(including negative integers), find all unique permutations that do not have the same number next to each other, then print them all out. If no permutations were found, print Nothing or return an empty list or any consistent output indicating that none were foun...

code-golf array permutations

DLosc

@UnrelatedString Is $ function composition?

Nitrodon

$ is defined as f $ x = f x. Its main use is that it binds last.

Unrelated String

01:05

welp gtg

@DLosc it's application with different precedence

Nitrodon

print $ f 88 means the same thing as print (f 88), but doesn't require parens.

Aiden Chow

how to print multiple times in the same code, i try main=print (...) on the second line, it dont work

Nitrodon

do is the "normal" syntax for binding two IO functions.

or you can use >>, which do is just syntactic sugar for in this case

Aiden Chow

@Nitrodon yeah, noob at programming here, i have no idea what that means

how to use that

Nitrodon

with >>

Aiden Chow

01:08

ok thank you

Nitrodon

with do

DLosc

@Nitrodon Okay, that's interesting. So (in C terms) $ is lower-precedence than the default implicit application operator

Nitrodon

exactly

DLosc

@AidenChow Don't worry, Haskell terminology is famously confusing even to experienced programmers of other languages. That's why I've been looking forward to having someone to teach it.

Bubbler

Implicit application operator has precedence 11 (or 12?, which is the highest possible). $ has precedence 0 (lowest possible).

Aiden Chow

01:10

what does "binding" mean in this context?

Nitrodon

I just meant precedence

user

Is it also right associative?

Nitrodon

I really should know, but I'm rusty.

Bubbler

Yes, f$g$x is f (g x)

while f g x is (f g) x

user

@UnrelatedString wait what does that mean?

DLosc

01:13

@Bubbler Would it be fair to say then that $ is essentially like an open parenthesis that autocloses at the end of the expression?

user

I’m having a hard time parsing English today

Nitrodon

yeah, that's accurate

Bubbler

I guess you can think of it like that

DLosc

@user Rephrased: Haskell has anonymous functions, but the syntax isn't very golfy, so you'll usually see named functions in code golf instead.

user

Oh

I thought they were just \x->fda go jh or something

Bubbler

01:15

\x y->whatever is kinda golfy but is equal in length with f x y=whatever and loses to x!y=whatever (infix binary definition)

Nitrodon

and it sometimes loses to point-free definitions

Bubbler

and also loses badly when you want to use guards

Nitrodon

You can use guards in lambdas?

Aiden Chow

okok slow down: what is infix binary definition, point-free definition, and guards??

Bubbler

or pattern matching, I guess

Aiden Chow

01:18

also how do you call the function \x y->whatever, with f??

Bubbler

Infix binary definition: you can use symbols as names, which is then parsed as a binary operator like + in a + b. You can use any symbol that is not already defined, so common symbols used are !, #, ? iirc

Nitrodon

@AidenChow You use it as an input where a function is required

Bubbler

\x y->whatever is an anonymous lambda like Python's lambda x,y:whatever or JS's (x,y)=>whatever. You can give it a name like f=\x y->whatever and then use f to call it.

Aiden Chow

@Bubbler so that can only be used when there is 2 arguments?

Bubbler

Two or more arguments.

Aiden Chow

01:23

@Bubbler could you give example for more than two arguments

Bubbler

f x y z=... can be defined as (x!y)z=... and it saves a byte

Pointfree: Using various techniques, a function can often be written in a way that does not name the arguments at all.

In the simplest form, f x y=x+y can be transformed to f=(+).

More sophisticated transforms are possible but learning how to do it requires some understanding of lambda calculus and combinatory logic, so as a beginner you can just remember the site pointfree.io that does the transformation for you. (Note that it doesn't guarantee an optimal transformation.)

Pointfree form has the additional advantage in golf in that, like an anonymous lambda, you don't need to count leading f= in the score.

DLosc

For those of us who know a little combinatory logic, what are the main combinators in Haskell? I remember seeing flip in some answers--I assume that reverses the order of arguments. And I think . is composition, right?

Bubbler

Yes, flip and . are the most common building blocks, followed by >>=, =<<, and <*> when you need to reference an argument multiple times.

I always forget what the three exactly do on functions though...

Nitrodon

was >>= the one that acts like the S combinator on functions?

Aiden Chow

what are some simple challenges for us new to haskell that we can do

Bubbler

01:35

All three are some variations of S

DLosc

S is the one that does S(f, g, x) => f(x, g(x)), right?

Bubbler

Yes

Aiden Chow

what are combinators, and how are they used in code?

DLosc

@AidenChow HMC: Given a nonnegative integer, return its factorial.

Aiden Chow

uhhh, is there recursion in haskell

how to do conditionals in haskell

Bubbler

01:43

Conditional: if cond then x else y

if, then, else are keywords

Aiden Chow

ok thanks

Bubbler

cond must be of type Boolean (no implicit coersion or truthy/falsy) and x and y must have the same type.

Recursion: Name the function f and use the same name f in the body. That's it.

Aiden Chow

@Bubbler is the condition similar to python conditions (like == for equals)

@DLosc tio.run/##y0gszk7Nyfn/…

DLosc

@Bubbler Looks like maybe >>= takes the one-argument function on the left and =<< takes it on the right. Not sure yet what the difference is between =<< and <*>.

@AidenChow Nice ^_^

Bubbler

@AidenChow Comparison operators are mostly the same but you use /= instead of !=.

DLosc

01:49

Now here's one cool thing about Haskell: You can write multiple definitions for the same function, and it'll use the first definition that works for the arguments you passed. Try it online!

Aiden Chow

@DLosc oh, huh thats cool

emanresu A

Many languages have that.

Typescript and elixir for starters

Aiden Chow

@emanresuA i have no idea what languages those are but thats pretty nice

certainly wish desmos would have something like that -_-

Bubbler

And it's also a nice task to introduce guards. The "multiple definition" way only works by pattern matching (e.g. it can only test for equality for integers), but guards can have arbitrary boolean condition. Try it online!

The syntax is f args | cond1 = body1 | cond2 = body2 | ...

emanresu A

@AidenChow Desmos isn't meant to be a programming language

Aiden Chow

01:54

@Bubbler do you always have to put otherwise for the last statement or is there some golfy way to do that

DLosc

@emanresuA I'm mostly familiar with it from Prolog. (I guess function overloading in C and related languages is kinda similar, but not really useful in the same way.)

Bubbler

For the last guard, using otherwise is recommended in production, but it's just an alternative name for True, and it can be further golfed to 1>0.

DLosc

@emanresuA Doesn't mean it can't have nice features... Besides, this is very related to piecewise functions, which are important in math.

Bubbler

So the golfed code would be f x|x>0=x*f(x-1)|1>0=1.

Aiden Chow

is there a builtin function of some sort for factorials, or do you have to implement it by urself

emanresu A

01:57

@DLosc I guess, yeah.

Bubbler

Factorial is not a built-in, but it is actually as simple as f x=product[1..x]

[a..b] is range syntax that creates a list of numbers from a to b inclusive, and product is a built-in that multiplies all numbers in the given list.

The full list of functions available without imports can be found here

Aiden Chow

@Bubbler dang, that is quite a lot

Bubbler

Yeah, and it's loaded with math terms too

Aiden Chow

what, how can there be infinite lists

Nitrodon

easily

Haskell is lazy.

Bubbler

02:03

You define an infinite list, and Haskell only actually computes what is actually needed from that list

and the definition of infinite list can also be recursive, which gives some advantage in certain sequence challenges

Nitrodon

A simple recursive list

Bubbler

Also a "canonical" example of defining Fibonacci as a recursive infinite list

Basically it defines the sequence using the initial terms and the recurrence relation

DLosc

@Bubbler drop 1 is just tail, right?

Bubbler

Right

I forgor most of Haskell prelude lol

DLosc

HMQ: Given a list of integers with at least two elements, add the first two elements together and put them back in the list. For example, [2,3,4,10] -> [5,4,10].

Bubbler

02:09

... that would require some introduction to pattern matching with lists

DLosc

Indeed ^_^

Bubbler

Basically a list in Haskell is a linked list, constructed using "nil" [] and "cons" :

The first item of a list is called head, and the rest is called tail (which are also the names for the built-in functions)

Nitrodon

[2,3,4,10] is actually 2:3:4:10:[] (and I remember a PPCG challenge which had you "desugar" strings similarly)

Bubbler

A common technique to calculate something on lists is to pattern match on it.

You can divide the input into two cases: either the input is empty, or it is not empty.

emanresu A

@DLosc Something like head x + head tail x : drop 2 x?

Bubbler

02:14

And when it is not empty, you can extract its head and tail immediately like this:

user

@Bubbler or some ugly tail calls (fet it? Heh)

DLosc

@emanresuA You want head instead of fst, I just made that mistake myself

Bubbler

f [] = something
f (h:t) = another thing

Nitrodon

fst takes a pair

Bubbler

For example, a built-in function product (returning 1 for empty) can be defined as

emanresu A

02:15

@Bubbler So, destructuring?

Bubbler

product [] = 1
product (h:t) = h * product t

Nitrodon

Almost got it. head tail x tries to apply the head function to the tail function, which doesn't make sense and is a compile-time error.

emanresu A

head $ tail x then?

Nitrodon

no, because $ has lower precedence than :

head (tail x)

Bubbler

Use parens first, and then try to eliminate parens when possible

DLosc

02:16

It's a bit disappointing that head.tail x has the wrong precedence too

Nitrodon

yeah

DLosc

Hm, I just discovered the !! operator, though... that saves some bytes over head

Aiden Chow

lol mightve overcomplicated it a bit idk

tio.run/##y0gszk7Nyfn/…

was looking through the documentation for stuff i could use

emanresu A

f(a:b:c)=a+b:c ?

Bubbler

And the pattern matching can go further, like if you want to match first two elements and the rest, you can pattern match (h1:h2:t)

Yeah, you got it already

DLosc

02:21

@AidenChow Haha, nice! X^D That idiom for "all but the first two list elements" is very Desmos.

emanresu A

Yeah lol

Aiden Chow

@emanresuA its that simple????

-_-

emanresu A

@DLosc That'd be f(A)=A[3...A.length] in desmos right?

Nitrodon

(\x->l!!x) can be shortened to (l!!) too

Aiden Chow

@emanresuA yeah

it could be even shorter like A[3...]

DLosc

02:24

@AidenChow In Haskell, this is drop 2 A (that is, get rid of the first two elements of A and return the rest)

Bubbler

An extreme example of list destructuring in action

emanresu A

@Bubbler As expected, golfed by xnor

Nitrodon

yeah, do is pretty unintuitive when not used in the usual context.

Unrelated String

@DLosc it is useful to think of it as an infix function since you can use it for things like map($1)[succ,id,(*2)] to apply each of [succ,id,(*2)] to 1

also ($) is actually sort of a specialization of id

DLosc

What is Haskell's comment syntax?

Nitrodon

02:31

In that golfed version, what does do b:c:d<-[t] do when t=[]?

Unrelated String

-- for single line

{- ... -} for multiline iirc

@Nitrodon fail

Bubbler

and multiline comment can be nested

emanresu A

That's good

Aiden Chow

@Nitrodon what does it even do when t is anything???

like just explain what that code is supposed to do, thanks

Nitrodon

@UnrelatedString but there's no error when the entire function is called on a 1- or 2-element list

Unrelated String

02:32

lists are a MonadFail iirc so if a pattern match in do-notation fails it just goes to the defined failure value of []

instead of erroring

Bubbler

Iterate over single-item list [t], filter the elements that match the pattern b:c:d, and flat-map using the next expression

That's how list monad works

Unrelated String

think of it like prolog ~~because as we all know prolog is the most intuitive language in existence~~

Nitrodon

do x<-foo; bar x is equivalent to foo >>= bar, where >>= translates to flat-map for the list monad.

Jo King

i actually like prolog

Nitrodon

I had an x there, so foo >>= (\x -> bar x)

Bubbler

02:36

Right, I just realized

Nitrodon

do syntax is more "natural" with monads like IO, where it basically acts like an imperative sequence of instructions.

but since it's just syntactic sugar, it works for all monads

DLosc

@AidenChow See, now we've gotten into the part where I'm completely lost ;)

Unrelated String

@Nitrodon as such you can actually filter out "branches" where the pattern match fails

Nitrodon

What is MonadFail anyway?

Aiden Chow

ok so can someone explain what do does exactly, cant make any sense of what yall are saying

Unrelated String

02:41

since lists are lazy you can basically just use the list monad to write backtracking algorithms

Nitrodon

do is a bit hard to explain in full generality.

Unrelated String

^

Nitrodon

It pretty much requires you to understand what a monad is.

Aiden Chow

@Nitrodon a what?

DLosc

HMQ: Given a row of Pascal's triangle, generate the next row of the triangle.

Aiden Chow

02:43

so do is higher level stuff right

Nitrodon

For now, just treat do as something you can use to do multiple things in your main function.

Jo King

@DLosc 25 bytes

Nitrodon

do in the IO monad is normal stuff. do in an arbitrary monad is unintuitive.

Unrelated String

@JoKing and a funny pointfree version that's 2 longer

Aiden Chow

how to add corresponding elements in two equal length lists

Unrelated String

02:48

zipWith(+)

Nitrodon

I can try to explain monads if you want. Do you know what a functor is?

Aiden Chow

@UnrelatedString ok thanks, i just put the two lists as arguments after it right

Unrelated String

ye

Aiden Chow

ok

not as good as other peoples', but heres my attempt: tio.run/##y0gszk7Nyfn/…

DLosc

@UnrelatedString I've also got a 27-byte pointfree version, but it doesn't parse if I put the function name in the header.

Oh--I need that -cpp flag?

Unrelated String

02:52

yeah

DLosc

Aha

Unrelated String

it just slaps the c preprocessor on iirc lmao

Jo King

is there a short way to check if the length of a list is less than x?

DLosc

@AidenChow Not bad! [0]++l is the same as 0:l

emanresu A

6

A: Ken Iverson’s Favourite APL Expression?

Haskell, 26 25 bytes o l=zipWith(+)(0:l)l++[1] Try it online! Saved 1 thanks to @ovs New approach, it essentially do this: 0[1,2,1] + [1,2,1] = [1,3,3] + 1 Previous version 30 bytes o=(0#) x#(v:w)=x+v:v#w x#_=[x] Try it online!

Jo King

02:57

i mean, i didn't look it up if that's what you're suggesting

emanresu A

No, I'm just saying that's probably the optimal solution

DLosc

HMQ: Given n, return the nth row of Pascal's triangle.

Sandbox Posts

0

A: Sandbox for Proposed Challenges

Smallest Bit Rotate integresequencecode-golf Input a positive integer. Rotate it bits 0 or more bits. Output the smallest possible rotate result. For example, when input is 177 $$ 10110001_{(2)}=177 \\ 01100011_{(2)}=99 \\ 11000110_{(2)}=198 \\ 10001101_{(2)}=141 \\ 00011011_{(2)}=27 \\ 0011011...

Nitrodon

Hint: you can match multiple patterns.
```
f 0 = [1]
f n = stuff
```

Aiden Chow

error: Not in scope: data constructor ‘F’ ???????

Unrelated String

03:06

use lowercase

Aiden Chow

tio.run/##y0gszk7Nyfn/…

Unrelated String

uppercase is reserved for Type Stuff™

DLosc

45 bytes, point-free

Aiden Chow

@UnrelatedString oh

tio.run/##y0gszk7Nyfn/…

@DLosc what the

not even gonna try to understand that

Unrelated String

for example you would be able to use F if you'd done data MyAlgebraicType a = F a in which case you'd have F :: a -> MyAlgebraicType a

@AidenChow it's actually not that complex if you unpack all the infix stuff

Nitrodon

03:10

Incidentally, that do in your footer can be simplified to mapM (print.f) [3..7]

(which means now I actually know what mapM is)

Jo King

@DLosc 40 bytes

DLosc

@AidenChow It's based on my solution to the previous HMC. Applying iterate to that function, starting at [1], creates an infinite list representing the entirety of Pascal's triangle. Then the !! uses indexing to select a single row.

Jo King

and mine is my solution but with a recursive infinite list

Unrelated String

speaking of unpacking infix stuff it can actually be 44

Aiden Chow

dang ok thats actually smart, though idk what iterate does

Unrelated String

03:13

oh yeah recursive infinite lists are a really nice way to show off what haskell is

Nitrodon

@AidenChow iterate f x = x:iterate f (f x)

Unrelated String

@AidenChow iterate f x is a list [x, f x, f$f x, f$f$f x, ...]

Jo King

@AidenChow iterate just repeats a function on a value to generate a lazy infinite list, so iterate(+1)1 will create a list of positive integers

i saw everyone else post their explanations, but posted mine anyway

Aiden Chow

ok uhh ill just assume yall are saying the same stuff, because i still dont really get it...

what does $ do??

Unrelated String

function application

with different precedence and associativity

don't worry about it, it's irrelevant

f$f x is the same as f (f x)

Aiden Chow

03:16

@UnrelatedString ah finally something i can understand

so iterate just applies the function over and over again?

Unrelated String

yep

infinitely

DLosc

@AidenChow An iterated function is when you apply the same function several times in a row, like f(f(f(x))). Haskell's iterate makes a list of the results if you apply the function 0 times, 1 time, 2 times, etc.

Aiden Chow

ok that seems to be a very helpful function, i will try to keep that in mind

Unrelated String

you can go pretty far by searching for things on hoogle

Aiden Chow

@Nitrodon so what does mapM do?

Unrelated String

03:19

if you feel like something probably exists but you don't have the faintest clue what it's called, you can search for it by its type

Nitrodon

In the context of the IO monad, for each element of the list [3..7], it applies the function (print.f) on it and does that action.

Aiden Chow

@UnrelatedString wdym by type

Unrelated String

...

Nitrodon

We're golfing everything and not including type annotations.

Unrelated String

i'm not entirely sure how to explain type tbh

Nitrodon

03:22

The type a -> a represents a function from a to a.

Aiden Chow

how do i search for its type, is it like integer, boolean, function, etc.?

Unrelated String

(fun aside: since haskell's polymorphism is parametric, id is the only possible distinct a -> a)

Aiden Chow

like wdym by searching for type

Jo King

if for example you want a function that gets the length of list, you can search for [a] -> Int

Nitrodon

The type of iterate would be (a -> a) -> a -> [a], since it takes a function and an a and returns a list of a.

Aiden Chow

03:23

@Nitrodon so what is the difference between mapM and map?

DLosc

@AidenChow Yes, but there's no function type: each function's type is based on the types of its arguments and its return value

Unrelated String

and if you want a function that repeats a list some finite number of times, you can search Int -> [a] -> [a]

Nitrodon

map will apply a function to each element of a list, and return a list.

Jo King

@AidenChow spooky monads

Unrelated String

as will fmap, which works on any functor

Nitrodon

03:24

fmap does effectively the same thing as map, but for any functor.

Unrelated String

and has the nice infix synonym of <$>

DLosc

03:59

@JoKing Unfreeze please? ^^

Jo King

as long as you do more than say thanks and let it freeze again :P

DLosc

Lol, will do X^D

Nitrodon

It's unfrozen.

Unrelated String

oh yeah we should probably mention list comprehensions

DLosc

JoKing or Bubbler, could you migrate the conversation starting from my "What's a monad?" question?

Unrelated String

04:02

and do more actual cmcs

Jo King

→ 6 messages moved to Of Monads and Men

Bubbler

...I think the relevant conversation is much longer than that?

Unrelated String

probably the entire thing about functors

PyGamer0

@JoKing whoa there is a haskell chat

Jo King

→ 63 messages moved to Of Monads and Men

PyGamer0

04:07

and there is LYAL

Aiden Chow

ayo im back

the frick happened here

Unrelated String

haskell

Aiden Chow

why is there a bunch of msgs moved

Nitrodon

because they were too technical for LYAL, I guess?

Aiden Chow

@Nitrodon oh, "too technical"? makes sense, i couldnt understand 90% of what yall were saying

Nitrodon

04:18

@UnrelatedString We were going to discuss list comprehension over here?

Unrelated String

oh yeah

Jo King

i don't know the exact specification of list comprehensions, but i think it's something like [element | a <- list, condition a], right? plus a lot of wiggle room for multiple lists and conditions

Unrelated String

^

Aiden Chow

@JoKing what does <- do

Unrelated String

it's part of the list comprehension syntax

does the same thing as it does in do notation pretty much

Jo King

04:24

so you could do a single element condition like [1|even a] to get [1] when a is even

Bubbler

It is a syntax indicating that a gets each element of list

Unrelated String

oh yeah i totally forget you can just do that

Jo King

[element | a <- list, condition a] is equivalent to python's [element for a in list if condition(a)]

Aiden Chow

@JoKing ok yep that makes sense

Bubbler

Haskell's is more powerful because you can pattern-match on a in a <- list like h:t <- list (which conveniently ignores elements of list that do not match the pattern)

Jo King

04:32

HMQ: Given n, return a list of the unique products of all pairs of ints that add to n, e.g. 6 => [1*5,2*4,3*3] => [5,8,9]

DLosc

@JoKing Positive ints, I assume?

Jo King

right, yes, forgot to specify

though, you know what, including non-positives can be a bonus challenge ha

DLosc

@JoKing That'd be an infinite list, methinks

Bubbler

@JoKing In any order?

Jo King

@DLosc totally fine to return wink, as long as you can prove it will eventually return everything

@Bubbler any order, i should probably also specify that the return should be [Int]

Bubbler

04:38

wait no, I have to halve it anyway

Aiden Chow

this probably works??? tio.run/##y0gszk7Nyfn/P00hzzY6UStPN1ErsSbRRjfaUE8vT98oNvZ/…

Jo King

violates both "unique" and "the return should be [Int]"

though that can be solved by just using div instead of /

Aiden Chow

@JoKing whats the difference

Bubbler

Yeah, this is at 29

Jo King

div is integer division

Bubbler

04:43

/ is real division, div is integer division (flooring)

Jo King

i was trying to illustrate more complex list comprehension e.g. this, but i forgot about math shortcuts >.<

Bubbler

ah lol

Unrelated String

lol

DLosc

I'm trying to write \a->(10-a)*a in point-free form. Thinking that =<< was a (reversed) S-combinator, I wrote (10-)=<<(*), but that didn't work. What am I doing wrong?

Aiden Chow

i still dont fully understand what point free form is

what indicates that some code is in point free form?

Unrelated String

04:55

> (reversed)

that's where you're wrong :P

DLosc

Oh--looks like I just had it backwards, lol

Nitrodon

oh, it was =<<?

DLosc

After our whole big discussion about >>= being a kind of flatMap generalization, I somehow got the idea it couldn't be applied to functions.

Unrelated String

the Monad instance for functions is

weird

Nitrodon

(->) a is also a monad.

Unrelated String

04:57

^

DLosc

Yeah. No need to go into why at the moment. :P

Nitrodon

It's basically a box that you put a value into and get a value out of.

Bubbler

@AidenChow \a->(10-a)*a is not point free because it calls its argument by its name. (*)=<<(10-) is the same function but does not use its argument's name anywhere, which makes it point free.

Unrelated String

all you have to know is (f=<<g) x = f (g x) x and (f<*>g) x = f x (g x)

and pure is const

Aiden Chow

@Bubbler hmm ok, how would you go about making point free code, and is it better than other forms

Jo King

04:59

"points" are the values the functions are acting on. a point free function is a function that doesn't mention those values explicitly, usually as a combination of other functions

Transcript for