The Nineteenth Byte

idea for chess variant: the two armies are positioned infinitely far away from each other, on an infinite chessboard, one being infinitely far to the side and down (not sure how bishops work currently)

ASCII-only

Infinitely far away?

Destructible Lemon

the rook and queen and bishop can move infinite distance

ASCII-only

The pawns and knight are useless

Destructible Lemon

@ASCII-only useful for defending the king

ASCII-only

pawns aren't

Destructible Lemon

1:22 AM

they're sort of useful

ASCII-only

you can literally go around the pawns

also how would the board even be represented physically

Destructible Lemon

@ASCII-only they're still useful as barriers

ASCII-only

@DestructibleLemon not behind the king...

Destructible Lemon

@ASCII-only you can represent positions as if the two boards were not connected

ASCII-only

@DestructibleLemon what if you move a bishop to the middle of the two boards?

quartata

1:23 AM

maybe something uncountably infinite: finite number of squares, but you can be anywhere between two squares

ASCII-only

@quartata O_o

Zacharý

I've actually had this idea before (real-valued board)

Destructible Lemon

for example, A|-1, -4 would represent a position behind one of the armies, and to the left

@Zacharý cool

quartata

obviously you'd have to change how things move a bit

Destructible Lemon

the only thing is figuring out the angle between the boards

Leaky Nun

1:24 AM

the pawns can never reach the kings

quartata

I think the easy thing would be just "you can land anywhere within the square you stop on"

ASCII-only

@DestructibleLemon 45 degrees

quartata

rather than like right on the center or whatever

pawns could still be useful that way

Zacharý

Anyone here know modgrammar?

ASCII-only

@Zacharý modgrammar is terrible

Destructible Lemon

1:25 AM

ok so, how does jumping versus movement work?

Zacharý

...

Destructible Lemon

does the pawn jump in real chess

as in real positions between spaces

quartata

not sure what you mean

ASCII-only

@DestructibleLemon huh?

Destructible Lemon

basically

ASCII-only

1:26 AM

@Zacharý why

Destructible Lemon

I'm talking about real chess as in, coords are reals

Zacharý

Jagony

quartata

yes that's what I'm talking about

3 mins ago, by quartata

maybe something uncountably infinite: finite number of squares, but you can be anywhere between two squares

Zacharý

@DestructibleLemon I'll happily share ideas that I've come up with

Destructible Lemon

if a pawn is at (0,0) for example, if something is at (0,0.5), can the pawn move forward

quartata

1:27 AM

you were talking about countably infinite before, like integers

Destructible Lemon

i find this new idea intriguing

ASCII-only

@quartata hmm would this be like smoothlife

Destructible Lemon

question: is rational chess equivalent to real chess? i think it is

quartata

@DestructibleLemon no because it can't capture that way

ASCII-only

oh someone should post a challenge about finding equivalents of GoL things in SmoothLife

quartata

1:28 AM

it would be blocked

Destructible Lemon

@quartata no i mean because, if a knight had something in front of it, it can still move because it jumps

quartata

right

Destructible Lemon

while a rook is a rider, a pawn is not

ASCII-only

@quartata what way can it capture? 30-60 degrees?

Zacharý

Maybe make it so within the path of movement, there cannot be a piece <1 square away (unless it's at the end of its movement path)

quartata

1:28 AM

@ASCII-only yes, diagonals

@Zacharý that eliminates the point, IMO

Destructible Lemon

you can't easily extrapolate from regular chess from whether a pawn moves or jumps its one space

Zacharý

Kings movements would be: max(|dx|,|dy|)=1

Destructible Lemon

@quartata possibly not

ASCII-only

@DestructibleLemon it moves one space

Destructible Lemon

having a piece on 4.5,4.5 prevents occupation of 4 squares

ASCII-only

1:30 AM

@DestructibleLemon *parts of four squares

Destructible Lemon

but you'd need to be consistent about how it works

@ASCII-only yes

quartata

all I was proposing was that you move to any x,y such that floor(x), floor(y) matches how it moves in normal chess

Destructible Lemon

new room?

Zacharý

Unless of course, the pieces avoid the capture region

quartata

once you're in a square you can't move a fractional amount within that square, without moving out of it

that's how you can block

you can't just move around things

Zacharý

1:31 AM

Nah, sqrt(dx^2 + dy^2) >= 1

Destructible Lemon

what if pieces represented points

quartata

also, I actually agree that using rationals would be better

easier for players

Destructible Lemon

but is it equivalent?

Zacharý

I would program my version of Real Chess... but it would be WAY too much work.

quartata

@DestructibleLemon good enough

the point is not how you label the positions

Destructible Lemon

1:32 AM

i think it might be

quartata

just that the set of positions is uncountably infinite

Destructible Lemon

ok

are pieces represented as points or areas

quartata

@El'endiaStarman can ArbyChess do this?

@DestructibleLemon points

Zacharý

|Q|=|N|, just to make sure you guys know

Leaky Nun

cardinality is a construct

Zacharý

1:33 AM

Points, with "capture regions" or someting similar

quartata

@Zacharý ...oh, right. god I'm tired today

Destructible Lemon

@Zacharý ok so is this saying rationals are countable?

quartata

@DestructibleLemon yes

Zacharý

Yes

quartata

there's a reason my bio says "idiot as a side gig"

Destructible Lemon

1:34 AM

ok... i still think that it's equivalent though

so you said something about a floor function

quartata

that was just for movement

that is, you move to a place within the square where you would move in normal chess

Zacharý

Do you plan on implementing this

quartata

no

Destructible Lemon

@quartata this is not what i was thinking

quartata

it would be a nuisance anyways because of floats

Zacharý

1:35 AM

SYMPY

Destructible Lemon

@quartata I think you could implement it in such a way that there are no rounding errors

quartata

not with floats

Destructible Lemon

because you only need like 64 values

quartata

floats would just be like having a really huge board

Destructible Lemon

and which are greater and less than

quartata

1:36 AM

I legitimately want arbitrary precision

Zacharý

The big problem I see is if you have complex movement rules: trying to implement check and checkmate ...

quartata

even if players are unlikely to need it

Destructible Lemon

@quartata yeah, but you don't need to store arbitrary precision like this

Zacharý

Move a piece to (pi,e) !

quartata

@Zacharý awh hell yeah

ASCII-only

1:37 AM

@quartata and the further away you go the more spread out the possible spots are :P

Destructible Lemon

you only need to store whether a position value is equal to, or greater, or less than, another piece's position value

which is basically sorting a list of pieces twice or something

quartata

@ASCII-only that wouldn't be a problem, we'd only store the fractional part as a float

i.e the position within the square

Zacharý

Are check and checkmate going to exist?

quartata

i don't know i suck ass at chess

Destructible Lemon

you don't necessarily need to express it as rationals

quartata

1:38 AM

i'm pretty much just interested from a pure board game perspective

@DestructibleLemon i'm back to reals now

Zacharý

I'm interested as I've had this idea.

Destructible Lemon

either way

quartata

we need someone who actually knows chess

Destructible Lemon

the only thing that the rational/real yields is whether or not you're blocked by a piece and could capture it

quartata

in other words, we need @Doorknob

ASCII-only

1:39 AM

@quartata define knows

Destructible Lemon

this is why you don't need to store the actual positions in lossy ways

ASCII-only

@quartata also what are capturing rules?

Zacharý

< 1 from the point

quartata

@ASCII-only 1500+ elo

ASCII-only

:||||||||||||||

quartata

1:40 AM

@ASCII-only being directly on the point

Zacharý

@quartata ... you're joking, right?

ASCII-only

@quartata :||||||| are those the people who try and capture your rooks as early as possible

Zacharý

:||||| why are we spamming or's?

quartata

why would I be?

Destructible Lemon

@quartata i have 1500 (i think that's the starting value) because i have anxiety about losing points so i never play ranked at all

ASCII-only

1:41 AM

@Zacharý what's so bad about that

Zacharý

How would anyone capture anything?

ASCII-only

@DestructibleLemon starting is 500

quartata

@Zacharý you move onto the point

Destructible Lemon

@ASCII-only really?

i don't remember that

@ASCII-only a lot of places give new players 1500

ASCII-only

@Zacharý you move such that you'll be able to capture a piece next move

quartata

1:43 AM

I think maybe this is something where you have to play it to be able to reason about it

Zacharý

In that case, movement rules would have to be created such that it doesn't become impossible to catch a piece.

Destructible Lemon

i think you could definitely skewer or pin pieces if the king was easier to target

quartata

i can't envision a scenario where that would occur

Zacharý

Can you tell me your capturing rule for knights?

quartata

you can always move out of the square and move back into it, if you're on different points within the same square

Destructible Lemon

1:45 AM

so my idea would be called projective chess or something?

quartata

@Zacharý none of the capturing rules change, the only movement rule that changes is that you can only move to a point within the final square of the piece's movement

Destructible Lemon

i would prefer if it were just an extension of chess to the euclidean plane, such that a rook at (0,0), after a move, has at least one coord = 0

quartata

that is, you move one square or whatever, then place it down on a point within that square

Zacharý

Ah! Then that works fine then. Getting two real-chesses confused

quartata

yeah sorry we have two different systems brewing here

it's kind of a funny mix when you think about it

the movement rules are still discrete in essence, but you fit many pieces in the continuous part of each square

Zacharý

1:50 AM

*3

Mine. @quartata's, and @DestructibleLemon's ideas.

Destructible Lemon

i sort of have two

but one of them isn't being discussed right now

is there any difference between uncountable and countable systems for any of these related chess ideas?

also i think rationals will be useful for my projective chess variant, if you want to move a rook infinitely, but to a different amount of infinity than the opponents board

quartata

@DestructibleLemon I think maybe not for the purposes of mine...

Destructible Lemon

how possibly could your variant be impacted by rationals vs reals

Zacharý

Wait ... Two boards?! Did I miss something?

Destructible Lemon

I'm talking about my projective chess variant (with an infinitely large board)

except i'm not sure whether it is projective exactly

Doorknob

2:00 AM

@quartata what, the only thing I know about chess is how to lose

quartata

@Doorknob lies

Destructible Lemon

its more that there are things like points at infinity, but there are more points at infinity from there

i don't think it's projective at all

it doesn't have anything about parallel lines

ordinals would be used in the system

Zacharý

omega(d)! Ordinals?

Destructible Lemon

why is there an !

i don't understand

Zacharý

Haven't you seen the omega for set theory? It's like aleph null, but for ordinals. So I made "omega" sound like "Oh my god"

Destructible Lemon

2:12 AM

yeah, i was wondering why you were making a function call to omega and then finding its factorial

yeah i was looking at an article for it

Zacharý

Or maybe just multiplication :p

Destructible Lemon

maybe...

does factorial evaluate first?

Zacharý

Anyone know how to make a grammar not left-recursive?

Destructible Lemon

2:30 AM

reverse it?

El'endia Starman

@quartata Not yet. Besides, it can barely do regular chess. :P

Downgoat

@ASCII-only working on generics. Do we want generic functions?

quartata

@Downgoat yes you do

Downgoat

There is very limited use-case that I can think of for them

@quartata these aren't like C++ function templates though

Destructible Lemon

what is arbychess

quartata

2:31 AM

el'endia's chess engine

Destructible Lemon

oh ok

Downgoat

You can pretty much all of the time rewrite the same code using a common superclass

quartata

...instead of generics?

oh I see what you mean

well here's a usecase for you to chew on:

Conor O'Brien

CMP: what should a ! b do in a programming language, if ! is an operator?

quartata

template <typename T>
std::vector<T>& arrayManip(std::vector<T>& list) { ... }

Destructible Lemon

2:37 AM

@ConorO'Brien what type of language?

quartata

@Downgoat I may not care about the contents of the array

like say, when reversing an array

that's a good example

Conor O'Brien

@DestructibleLemon a "practical" one, specifically Attache

quartata

you would definitely want generics then

Downgoat

@quartata you should probably implement this as an extension

quartata

no

Destructible Lemon

2:37 AM

@ConorO'Brien then != is probably not appropriate?

quartata

just because it's monadic doesn't mean it should be an extension

Conor O'Brien

@DestructibleLemon no, there's already an operator for that

Destructible Lemon

perhaps a!/b! or whatever?

quartata

it could actually be manipulating another object and just happen to need the list. this was a simple example.

Downgoat

@ConorO'Brien bitwise not all bits in A that are not true in B

Conor O'Brien

2:38 AM

probably should mention that !a is already factorial

quartata

@ConorO'Brien ...it's not postfix?

Destructible Lemon

a!/b! is useful for permutations and stuff

ASCII-only

@quartata clearly we should just use my terrible chess engine that doesn't even work :P

Conor O'Brien

@quartata do you know how hard it is to implement postfix operators when prefix operators are a thing in my monkey patched shunting algorithm?

quartata

probably pretty hard

Destructible Lemon

2:40 AM

at what point does a definition of a number become actually about the number and not about "woah imagine a really big number"

ASCII-only

> monkey patched

:/

Conor O'Brien

@ASCII-only I've never found any good reference for robust shunting algorithms, and mine's kinda iffy

ASCII-only

@ConorO'Brien robust?

Conor O'Brien

ye

ASCII-only

what do you mean

is there even more than one

Conor O'Brien

2:41 AM

yes

you have your generic shunting algorithm

then you have those able to hand variadic function calling, unary operators of mixed precedence, operators which are more than dyadic, etc

ASCII-only

@ConorO'Brien oh. iirc Pytek has one of those

Conor O'Brien

and so does attache

ASCII-only

@ConorO'Brien variadic function calling?

@ConorO'Brien but isn't factorial just 1, 0-adic

Conor O'Brien

basically, allowing for functions without predefined arities

quartata

@ASCII-only yeah ours handled that shit I think

I don't know pytek is still a bit of a fever dream

Conor O'Brien

2:43 AM

@ASCII-only 1, 0-adic?

quartata

although ours also did not have parentheses

El'endia Starman

Will get to it! ... Before the heat death of the universe...

quartata

so uh

you know

@El'endiaStarman we need to redesign it from the ground up, it didn't have enough coroutines

ASCII-only

@ConorO'Brien why not just make operators any arity

Conor O'Brien

@ASCII-only well I don't like operators greater than dyadic

ASCII-only

2:44 AM

@ConorO'Brien :| then why do you have them at all

New Main Posts

0

Q: Console print a bar graph

The objective is to print a graph from an array of numbers, of the design below. Printing the X and Y scale exactly as in the "design", with padding, is part of the challenge. The input array of numbers can be of virtually any range of integers in X and Y, though I would suggest keeping it small ...

code-golf

Conor O'Brien

I don't

ASCII-only

oh.

@ConorO'Brien what do you handle?

postfix/prefix/dyadic isn't that hard

Conor O'Brien

statement flushing (basically good asi), implicit array creation (since [ is a function call in Attache), value discarding via parens ((a, b, c) being equal to c), inbuilt currying syntax, bracketed lambdas ({ ... })

and regular operators

ASCII-only

2:59 AM

@ConorO'Brien asi?

Conor O'Brien

automatic semicolon insertion

Downgoat

@ASCII-only do we want to give warn when you don't do anything with a function that returns

user202729

Why does tio.run/##y0rNyan8//9RwwwrY5VHjTsPTzi08P///yZGliaWZuZGlmYA work but tio.run/##ASIA3f9qZWxsef//4oCYOjPCteKBucOQwqH///80Mjk0OTY3Mjk2 doesn't?

quartata

You mean returns a value, right?

Nim makes it so you have to do discard f()

otherwise it errors

you might not like that if you end up working with C APIs a lot

they tend to return stuff like sizes that you may not usually need

ETHproductions

@user202729 I think it has something to do with the ‘ being included in the chain in the broken one, and excluded in the working one

Hmm, actually, if you add another µ before the broken one it seems to work

This works

user202729

3:15 AM

But not what I intended.

ETHproductions

Ah, I think I understand the problem: µ starts a new monadic chain to the right, so the Ð¡ doesn't actually have a link or chain to work with

Which is why it just gives None the first iteration

user202729

That's not Jelly...

The arity of the first chain is the arity of the link.

So it should be monadic.

Oddly adding a leading µ works. tio.run/##y0rNyan8///Q1kcNM6yMgVTjzsMTDi38//@/iZGliaWZuZGlGQA

ETHproductions

Is that what you wanted, incrementing on each iteration before the integer division?

user202729

call = lambda x = None, y = None: ntimes(links, (x, y), cumulative = True)

ETHproductions

The way I see it, without the leading µ it just executes the first three links, then the µ forces the parser to move on without regrouping the previous links, and therefore Ð¡ can't group the previous two links

user202729

3:21 AM

Looks like something calls call()...

I'm debugging...

ETHproductions

You can replace the $ with Ɗ to group the first 3 links together

user202729

Oh...

The parser think that the link is leading_nilad, so the first link is evaluated niladically. (huh?)

ETHproductions

ah. I understand now

wait... nilad?

user202729

Because:

ETHproductions

are you talking about the µ⁹Ð¡ or the first part?

user202729

3:26 AM

(1) Ð¡'s arity is the max of its childs' arity.

ETHproductions

wait... so is Ð¡ stealing the 3 from the first part?

user202729

(2) its childs are <1> the ‘:3 -> variadic, (-1) and ⁹ -> niladic, 0.

So its calculated arity is max(-1,0)==0.

ETHproductions

...oh

I would have assumed the variadic would be considered at least a (1)

user202729

Temporary solution: Denote variadic arity = 3.

ETHproductions

the question then is, would that break anything else?

hah, apparently the film-making company ETH Productions have changed their name to ETH Entertainment

DLosc

4:04 AM

@DJMcMayhem Of course! You can write the whole post if you want (I have no monopoly on that task); or I can write it and you can edit it afterwards.

DJMcMayhem

4:27 AM

I liked the format of the brachylog post, so I'll probably keep it pretty similar. I just wanted to fill out the brain-flak info

Downgoat

4:42 AM

@ASCII-only okay I've been working on making type deduction errors more clear in VSL. Is this understandable?:

Type Resolution Error: Call to function does not match any valid candidates. Valid candidates are:
    • func print(string: String) -> Void
    • func print(byteSequence: ByteSequence) -> Void
    • func print(bool: Bool) -> Void
    • func print(uint32: UInt32) -> Void
    • func print(int: Int32) -> Void
    • func print(uint64: UInt64) -> Void
    • func print(int64: Int64) -> Void
    • func print(float: Float) -> Void
    • func print(double: Double) -> Void
Instead, deducted to `func (*: Object) -> *` (3:15)

ASCII-only

Yes

Downgoat

okay well in other good news, this mean generics are work :D

Transcript for