Brachylog

Fatalize

07:23

@MartinEnder because integers is the first thing it tries (just an implementation side-effect) and since there are infinitely many of them…

if you didn't have the ẉ though and required a string further down the program it would work

ẉ is the one that "tries" integer values in that case

Zgarb

09:42

@Fatalize If ẉ ignores its right argument, why doesn't the predicate inside {} in this program find just one valid integer and then generate more outputs with ẉ?

Is an unconstrained variable counted as a single output for the predicate or something?

Fatalize

@Zgarb ẉ automatically labels its input if its an integer

so once you have ẉ in that predicate, that predicate will leave as many choice points as possible labelizations of that integer

findall collects the output variable, but it does so for each possible choice point, regardless of whether it impacts the output variable or not

Wait, but in that case you're dealing with strings

so really the thing generating the choice points is that ~ḅ

Fatalize

10:02

I'm not sure if that answers your question

Zgarb

10:16

I suppose it does. If I understand you correctly, the important thing is that ẉ does not create a choice point for its right argument, if it's not actually used for anything in the predicate.

Fatalize

ẉ only creates choice points if its input can be labelled as an integer

otherwise it indeed doesn't

Zgarb

I see some weird stuff happening with different commands. {≤ẉḋ}ᶠ⁾ prints only one number. {≤ẉṅ}ᶠ⁾ gives an error. {≤ẉℕ}ᶠ⁾ prints several numbers.

{≤ẉ^}ᶠ⁾ seems to loop forever for some reason.

Fatalize

The first one only prints one number because ḋ generates choice points (since its input is free) and so will bactrack on that first. If you ask for the output, you get your 9 results

The second one gives an error because of a new bug you discovered :)

Zgarb

Yey!

Fatalize

basically it negates an int first, and then on backtracking it will try to negate a float but float operations don't work on free variables

I forgot to add a check for that

?- run_from_atom('{≤ẉṅ}ᶠ⁾',[985,9],Z).
985
986
987
988
989
990
991
992
993

^ fixed, just need to push it to TIO

Zgarb

10:34

Some other arithmetic commands seem to have the same issue.

Fatalize

{≤ẉℕ}ᶠ⁾ works as expected

Zgarb

Abs and root at least.

Fatalize

{≤ẉ^}ᶠ⁾ loops infinitely because of another bug related to floats :p

^ on bactracking tries to compute the integer power of a float, but labels the integer before checking that the float is not a var

I just need to swap two lines…

Zgarb

{≤ẉṡ}ᶠ⁾ only prints half of the expected number of lines. What's going on there?

Fatalize

Fixed the bug for √ too

@Zgarb I get the same behavior for ^ after fixing it. Basically this is because ṡ leaves two choice points: either its input is 0, and then its output is 0, or its input is not 0, and then its output is abs(input)/input

so because you ask for 9 answers, and since ṡ leaves two choice points, it will only backtrack up to ẉ 4 times, thus printing 5 numbers (including the first pass)

Zgarb

10:46

I see.

Fatalize

That's a lot of float bugs

Zgarb

I'd guess that Prolog doesn't play well with floats in general.

Fatalize

That's not its forte no. You can't really manipulate them in a declarative manner, unlike ints

@Zgarb BTW did you consider nominating Husk to that language-of-the-month event?

Zgarb

@Fatalize I did consider it, but I was just going to implement a new feature that invalidated some existing syntax, so I wanted to wait for a while.

Fatalize

@Zgarb I've wanted to learn it for a while now but never found the motivation, so something like this would probably make me learn it

Zgarb

10:57

I'll likely nominate it later. :)

Fatalize

Are you the sole maintainer of Husk? Or is Leo still involved?

Zgarb

Leo has been busy for a while now.

Zgarb

11:14

@Fatalize Actually he posted a message in chat that I had missed. He won't have much time for PPCG in the foreseeable future, so I'm effectively the sole maintainer of Husk for now.

Fatalize

12:07

@Zgarb Who had the idea first of making Husk? Or did it come up when you were both talking to each other?

@Zgarb (do you still have snow in Montpellier? :p)

Rod

12:51

@Fatalize what would be the "right" way to reuse the input? for example how could I write (i+2)*i, I was thinking in something like +₂×₂w but replacing the second ₂ with the input

Fatalize

@Rod ? is the input variable, so you can do +₂;?×

Rod

@Fatalize thanks!!

Fatalize

A;B constructs a list [A,B]

Zgarb

@Fatalize We had thought about a Haskell-based golfing language independently, but I think Leo made the first push into actually implementing something and was looking for collaborators. (Montpellier is still covered in snow and pretty much paralyzed.)

Fatalize

I see

Rod

13:28

@Fatalize and how would that work for a superscript? like here to replace the ₅, I've tried the same syntax but it didn't work

Zgarb

@Rod You can use subscript parentheses: ^₂⟦₁;?ḍ₎w

Fatalize

^ this

the same thing exist for meta-predicates superscripts

Zgarb

Basically, ;? forms a pair of the current value and the input, and ḍ₎ means "evaluate ḍ on the left element of the pair, using the right element as a subscript".

Fatalize

And you don't need the ₎ for ^ because its default function is to expect [A,B] as input and output A^B

Rod

Thanks again

Fatalize

14:15

@all I really like this new challenge and had found a really cool solution to it (which is shorter than the current 05AB1E answer). I'll let some time to people interested in solving it before answering though

it's also shorter than Dennis' Jelly answer, so if you want to reap some green points, start thinking :p

… well Erik just answered :p, but you can still find something shorter

Martin Ender

14:35

hm, I can save two bytes just with a shorter main predicate, but I still have the 3-line format

Fatalize

I guess we have the same 7 bytes main predicate

you can avoid using the linebreaks

Martin Ender

can you just insert the copies of each predicate in a way that doesn't affect the truthiness of the result or something?

I guess you have to, otherwise you will add some additional character

Fatalize

Yes

Just try to write a tautology with your seven bytes after those 7 bytes

Martin Ender

yeah, I think I've got it

ọtᵐ=h≥2≥2ọtᵐ=h should work, I think

Fatalize

Yep

I had one with >1 instead of 2

ọtᵐ=h>1ọtᵐ=h1>

Martin Ender

14:40

heh, that's kinda neat too

Fatalize

It's almost two times the same thing, but had to put the 1 before the > in the second part

Also for style points (but 2 more bytes), you could get rid of the new lines and get a palindromic answer: ọtᵐ=h>1 1>h=ᵐtọ

Martin Ender

:D

mind if I post ọtᵐ=hℕ₂ℕ₂ọtᵐ=h?

Fatalize

Well no go ahead!

Didn't think of that one but that's actually the most elegant one

@MartinEnder Wait don't post it it's wrong

Martin Ender

oh yeah

if the character count is something like 112, that won't work

Fatalize

if e.g. you have 101 a in your string it wwon't work

that was too good to be true :p

Martin Ender

14:46

then I just move the h after the N2

Fatalize

your other solution is fine and the same length, just doesn't have that nice symmetry…

yeah you could do that

Martin Ender

I wonder if = would be more useful if it unified the output with that equal element.

Rod

how can I execute a predicate before pairing on the right side? tried with parentheses but it still failed : dl;(?d)j₍w

Fatalize

@MartinEnder From experience, it's not clear it would be better. We often use it to constrain some free variable and need the input list right after it

Martin Ender

I see

Fatalize

14:54

@Rod I'm not sure I understand what you mean

like you want the result of ?d to be used in j?

You would need to use named variables

For example: dXl;Xj₍w

You just call the result of ?d as X and reuse it further down

Martin Ender

I think I've got 12: ọtᵐℕ₂ᵐ==tℕ₂ọ

Rod

yes, exactly what i wanted

Fatalize

@MartinEnder Jeeeeeez

I think you're right

(good thing you found that too because they just posted a 14 bytes Husk answer :p)

Martin Ender

actually I could have also used t twice instead of using t and h

@Fatalize is the subscript column of writeln a typo in the docs?

Fatalize

@MartinEnder No but I admit that it's not very clear

basically the subscripts for writeln are the same as for write

Martin Ender

15:05

oh okay

I wonder whether there's a good solution that uses ọ twice instead of using =.

Fatalize

@MartinEnder Wouldn't ọtᵐọl1l1tᵐ work?

for 10 bytes

Martin Ender

that doesn't ensure that the count is at least 2, does it?

Fatalize

right

ọtᵐọhh>1tᵐ1> but still 12 bytes

Martin Ender

this doesn't ensure that there's only one run after the second ọ, I think?

Fatalize

right

—.—

Martin Ender

15:14

you need to make sure that the result after the second Occurrences is [[>=2,_]]

Fatalize

Maybe using ^ on that [>=2, _]

It would always be greater than 1 if non-discriminating

ọtᵐọ^ᵐ but still need to check that there's only one result and it's greater than 1

and reuse t

Martin Ender

are z and \ equivalent when the input is rectangular?

Fatalize

yes

(I think I'll implement something equivalent to Ċ and Ṫ but for a singleton list)

Martin Ender

that sounds useful

Fatalize

There's Ė = [], Ċ = [_, _] and Ṫ = [_, _, _] but somehow never thought of [_]…

Martin Ender

15:28

I guess currently, you'd do that with ~g?

(although that would give access to the element, not the singleton at the end)

so ~gg or something...

Fatalize

yes

which is ugly

Martin Ender

yeah

Fatalize

and also if you needed to reuse it somewhere else you would need to give it a name also

Martin Ender

true

Fatalize

I'll have to go soon, here is a potential idea for 10 or less bytes

hardest feature implementation ever

Martin Ender

15:37

:D

hm that group idea is interesting, because we can stuff quite a lot of predicates into the first one

I would have expected ≥ᵐ2 to work as an alternative to ℕ₂ᵐ, how come it doesn't?

Fatalize

ᵐ maps the input to the output

so you would need a list of 2s in the output

Martin Ender

ohh, okay

that makes sense

is there anyway to map a predicate only over input or output?

Fatalize

Not directly no

Martin Ender

I don't know how hard this would be to implement, but it seems like meta-predicates of the form "All elements of ? satisfy the predicate with ." and "Any element of ? satisfies the predicate with ." could be useful.

Fatalize

I don't think it would be that hard

I have to go, could you please submit an issue on Github so that I remember it?

Martin Ender

15:46

sure

Fatalize

Thanks, later!

H.PWiz

16:32

0

A: Non-discriminating Programming

Brachylog, 10 bytes =ᵍbᵐbᵐlᵍ=l Try it online! Explanation =ᵍ Group all equal elements together bᵐbᵐ Remove the first element of each group twice. This fails if there are fewer than 2 elements lᵍ Group elements together that have th...

I'm slightly surprised that ` =ᵍ` works

Martin Ender

Damn that's good.

Fatalize

17:12

@H.PWiz well damn

Martin Ender

it's tied with Jelly now though

Fatalize

@H.PWiz it works because ᵍ maps to each char of the string, and = on one char outputs that char

@MartinEnder that constraint that the program mus tbe non-discriminating makes this really interesting

Martin Ender

yeah, surprisingly.

H.PWiz

17:31

@Fatalize Cool, so its like ≡ᵍ on strings?

Fatalize

yeah

Transcript for