The Nineteenth Byte

12:00 AM

@dzaima Not sure. Note that it also says that The tokens ⍺ ⍺⍺ ⍵ ⍵⍵ can be used anywhere in the function. For parsing purposes, ⍺ and ⍵ are treated as arrays while ⍺⍺ and ⍵⍵ are functions., so I'm not entirely sure how to write p(+⍤q)⍹ where p and q both are non-magic arrays.

ASCII-only

@Downgoat hello world

Adám

@dzaima I'm also not sure why that's not written as (⌽⍤⍺)⍹ which avoids an intermediary derived monadic operator.

Downgoat

@ASCII-only oh... good point

dzaima

@Adám oh right (dop fn) is valid thing. :| me

Downgoat

ive wanted to add top level expression support for a while but not sure what order to execute in...

ASCII-only

12:03 AM

@Downgoat top to bottom

Pavel

@ASCII-only I think he means if function definitions should go up first

ASCII-only

hoisting? IMO, no

Adám

@dzaima The whole thing makes me somewhat uneasy, tbh.

ASCII-only

wow, there are a lot of parenthesis languages. we need more on TIO

Pavel

I too vote against hoisting

dzaima

12:07 AM

in statically compiled languages not hoisting most of the time is just a very arbitrary restriction imo

ASCII-only

of course. but it doesn't make sense

it's like time traveling

Downgoat

@ASCII-only but like if multiple files?

ASCII-only

@Downgoat still top to bottom

Pavel

@dzaima F# is interesting in that it puts all the code in a strict order, including the order files go in

Downgoat

@ASCII-only yeah but which file goes first

ASCII-only

12:09 AM

@Downgoat import order

Pavel

If File A.fs depends on B.fs, fsharpc A.fs B.fs will fail since it'll put B after A.

dzaima

what if function a wants to call b but b wants to call a?

ASCII-only

except circular imports. hmm

Downgoat

@ASCII-only no imports in VSL you just use glob to specify all sources

Pavel

let rec a() = g() and g() = a() // F# mutual recursion

ASCII-only

12:09 AM

@Downgoat oh

Pavel

@dzaima ^^

There's a special and keyword

dzaima

@Pavel but that ugly

ASCII-only

@Downgoat is there main

Downgoat

@ASCII-only there is main function but that would be called after top level expression

Pavel

@dzaima It's pretty rare that you ever need it, really.

dzaima

12:11 AM

@Pavel ok sure, but a special syntax for a thing that could easily be fixed by not being very annoying otherwise

ASCII-only

@Downgoat hmm. this will be a problem. how to find out order if program doesn't state order

unless, assume main file executes first, import as needed

Pavel

@dzaima It's mostly annoying for classes, since those have to be declared next to each other in the same file with and to be mutually recursive as well

dzaima

@Pavel oh ok thanks for explicitly telling me that F# is literally unusable

Pavel

@dzaima Nah, it really isn't a big deal. Mutually recursive anything is rare, and F# tends to have much smaller classes than C#, consisting of a couple lines at most.

dzaima

this counts as mutually recursive, right?

Pavel

12:14 AM

Yep

dzaima

ok so F# is unusable

Pavel

I'm not sure why you're saying that since what you just did in Java is perfectly possible in F#

dzaima

@Pavel but afaict you need an and in the middle there, and if both of those classes are huge it's forcing placing both in the same file

Pavel

type A =
    member this.b = B()
and type B =
    member this.a = A()

@dzaima They won't be huge though.

F# isn't C# or Java

F# classes are collections of data, you wouldn't normally put methods in them

dzaima

@Pavel ah

Pavel

12:18 AM

Instead, you would write all the functions operating on objects of that type after the definition of the types themselves

Downgoat

@ASCII-only another issue is if two global vars depend on each other one will get undefined value. I'll have to implement some algorithm to identify these cases

ASCII-only

@Downgoat yeah

Pavel

@dzaima Here's how most class definitions look like in F#: type A = { b: B } and type B = { a: A }

The code snippet earlier was the "long form" for full classes that can have methods and constructors and whatnot, but record types which are literally just a couple of values thrown together are more common.

dzaima

oh yep F# is unusable, it declares thing as name: Type ಠ_ಠ

Pavel

@dzaima Only when it isn't inferable

Look at how verbose Haskell type annotations are

@dzaima If you really don't like it though, you can also define record even shorter like this: { a : float; b : int } is equivalent to float * int

You can multiply types together and make new ones

Well, they're not quite equivalent

float * float won't have names for the fields

ASCII-only

12:48 AM

ok. help, how to make an interesting esolang/golflang

trichoplax

Who do you want to interest?

Pavel

Step 1: be ais

ASCII-only

@Pavel or Chris Pressey, right

@trichoplax myself mostly

trichoplax

@ASCII-only Then you can be sure of perfectly honest stakeholder feedback - you should be fine

ASCII-only

the thing is, i don't have any ideas :/

:|

-1

A: "Hello, World!"

brainfuck, 137 bytes ++++++++++[>+>+++>+++++++>++++++++++<<<<-]>>>++.>+.+++++++..+++.<<++++++++++++++.------------.>+++++++++++++++.>.+++.------.--------.<<+. Try it online! Explained : ++++++++++[>+>+++>+++++++>++++++++++<<<<-]>>>++. H >+. ...

trichoplax

1:05 AM

Something difficult to use or something fun to write or something fun to read...

1d, 2d, 3d, arbitrary extendable dimensions?

ASCII-only

@trichoplax what's this, (une|be|whatever)funge?

@trichoplax yeah the thing is, there's a 99% chance ais, chris pressey, conor or tux have done it before

trichoplax

Just trying to narrow down what you want to go for...

Deterministic or stochastic?

ASCII-only

anything really

well, I guess it depends what you mean by stochastic

trichoplax

Creative limitation

Creative limitation is the concept of how purposely limiting oneself can actually drive creativity. At a 2013 TED conference, artist Phil Hansen made several remarks concerning the value of limitations, among them that "We need to first be limited in order to become limitless,” and “If you treat the problems as possibilities, life will start to dance with you in the most amazing ways.”Creative limitation can also be thought of as a way to achieve a novel effect or goal that is not otherwise possible using conventional, readily accessible, methods. Igor Stravinsky used what he called creativ...

Maybe having too many options is the problem here

ASCII-only

True. Then deterministic (which is still a heck of a lot of options :P)

trichoplax

1:13 AM

By stochastic I meant that the internal behaviour of the program would be random (even if you can still write a program that gives deterministic output for a given input - it would get there a different way each run)

I didn't mean creative limitation to narrow down just that one choice. I was thinking if you place some arbitrary restrictions on yourself then it may spark creativity

ASCII-only

sure. but i can't think of "arbitrary restrictions" because there are too many options for those too :P

trichoplax

Like "draw a picture" is a hard challenge, because what do you draw? But "draw me a tree" is much easier because you don't have as much choice

@ASCII-only Yeah it comes back to the same problem...

So, do you want someone to impose some ridiculous arbitrary restrictions for you?

ASCII-only

well, not like i can think up of any restrictions myself >_>

trichoplax

How about a continuous alternative to grid-based languages?

ASCII-only

continuous = commands can be at arbitrary (even irrational) points?

@trichoplax

trichoplax

1:27 AM

Yes I was imagining something like a grid, where you move a certain number of squares in one direction, or turn 90 degrees, or read the value of the current square, or write a value to the current square, but without the grid. So you move an arbitrary distance in the current direction, or turn an arbitrary angle from the current direction. Reading and writing would not be to a well defined area like a grid square, but could be an area about the current arbitrary point. Perhaps a Gaussian blur

ASCII-only

hmm. so, kinda like how smoothlife works. also, just the memory and not the code then?

dzaima

or your program is written as an equation that calculates the codepoint at a given coordinate. no, that's too evil.

trichoplax

No idea how you deal with arbitrary numbers (floats/rationals/irrationals), so you'd have to have a fairly tightly defined spec to keep implementations matching

@dzaima Calculated from the surrounding area in a way that's different for each program?

ASCII-only

@trichoplax hmm. why reading/writing in an area though? (seems like it would lead to all sorts of irrational numbers)

trichoplax

@ASCII-only Yes similar to smoothlife. Also, I think smoothlife is approximated by progressively finer grids, so that might be a hint to a way of implementing something like this with only a square grid and floats, but with area of effect when reading and writing being blurred over a large number of squares

dzaima

1:33 AM

@trichoplax why surrounding area? program is just an equation with x and y as variables, and wherever the program pointer is, is input to it

trichoplax

@ASCII-only The other option would be only reading/writing at the current precise point, but that would mean a written point would have no effect on subsequent execution unless you get the pointer back to exactly the same point again

@dzaima I don't have any justification for thinking this is a good idea, just:

19 mins ago, by trichoplax

So, do you want someone to impose some ridiculous arbitrary restrictions for you?

Open to any alternative arbitrary restrictions...

ASCII-only

1:57 AM

oh yeah, @trichoplax would the value of a point on the grid be, say, the total amount of value in a square from (point.x - .5, point.y - .5) to (point.x + .5, point.y + .5)

trichoplax

I was thinking that each time you write, that specific point gets the exact amount you specify, and the points nearby get gradually decreasing amounts as you get further away, that add onto whatever value each point already has (or subtract, if you specify a negative amount)

Or (perhaps equivalently?) you could just write to that exact point, but when you read you get a weighted sum of all the points within some small range

ASCII-only

@trichoplax yeah this is what i'm thinking

trichoplax

Something like a Gaussian blur applied to the point you've just written to smear it out over the plane, with highest values at the centre and fading out with distance

Gaussian blur

In image processing, a Gaussian blur (also known as Gaussian smoothing) is the result of blurring an image by a Gaussian function (named after mathematician and scientist Carl Friedrich Gauss). It is a widely used effect in graphics software, typically to reduce image noise and reduce detail. The visual effect of this blurring technique is a smooth blur resembling that of viewing the image through a translucent screen, distinctly different from the bokeh effect produced by an out-of-focus lens or the shadow of an object under usual illumination. Gaussian smoothing is also used as a pre-processing...

ASCII-only

hmm. square weighting vs circle weighting? (circles may be more expected, but squares would give nice, rational numbers)

also, hmm. looks like gaussian blur has effectively infinite range

trichoplax

You could even make it time based, so each program tick a small amount of Gaussian blur is applied to the entire plane. Each time you write, you write a specific value to the exact point, but each program tick that point spreads out until eventually it has faded to nothing. More recent points are sharper, older points more faded and larger

ASCII-only

2:05 AM

@trichoplax wonder if it's even possible to program anything useful with this :P

trichoplax

@ASCII-only Yes it does. If you have a finite plane that won't matter too much, but on an infinite / arbitrarily large plane you'd probably want to limit calculation to some maximum radius, or minimum value before writing it off as zero

@ASCII-only I have absolutely no idea...

ASCII-only

@trichoplax it seems like n-body simulation algorithms might be useful here. hmm

trichoplax

Wow that looks interesting. Maybe multiple instruction pointers too...

Veskah

2:27 AM

Hmm, I wonder if there's a chess-like Esolang hiding out there.

If there's an incredibly obvious answer, just assume I'm oblivious

Veskah

4:34 AM

Hmm, I've pondered this a bit. 6 piece types, 2 colors, castling, en passant, taking, promotion, checking, and mate. There's a good deal of Opcodes in there

Bubbler

5:21 AM

@Veskah Just chess-themed or actually playing chess?

ais523

6:20 AM

there have been a few attempts at chess-based languages, I'm not sure if any were complete

InfChessPro may be closest

the obvious thing to do from my point of view would be to have an infinitely board that repeats, with the repeat patterns specified by the program, and an area that's an exception to the base pattern (especially as you'd need somewhere to put the Kings!)

and the interpreter just tries to find the optimal move, or at least a move that doesn't immediately lose

this sort of construction normally ends up Turing-complete, but not always

anyway, my advice for creating an esolang:
1. Think of an interesting feature.
2. Create a language with *just* that feature. Remove anything that you'd "expect" to go into a normal programming language, you might not need it.
3. Work out what the language is missing to make it usable for programming (if anything). Then attempt to sketch out a few programs in it (or actually write them if needed).
4. If the language doesn't have infinite memory, give it infinite memory in whatever way is most compatible with the programs you wrote in step 3.

I'd argue that the hardest steps are 1 and 3; 1 requires creativity, 3 requires programming ability (often I've had to get better at programming to be able to work on a language idea of mine)

2 requires discipline but is not all that difficult, so to speak

also, I didn't put "write an interpreter/compiler" anywhere on this list, and it's a step I often forget or fail at in practice, but obviously you'll need that to be able to use the language on PPCG/TIO too

Downgoat

6:52 AM

wtaf swift: tio.run/##Ky7PTCsx@f8/…

ais523

that's just a non-virtual method

Downgoat

@ais523 swift does dynamic dispatch on all methods

i.e. everything is virtual

ais523

AFAICT with a few experiments, if a method is overriden, which overriding version of the method is selected is done virtually

but method overloads are done in a non-virtual manner

so Swift sees two different methods f, neither of which overrides the other, and does overload resolution as is appropriate to an A rather than to a B (because overload resolution is presumably done statically by the compiler)

fwiw, I believe the only "correct" response to that program in a compiled language would be a compile-time error

FWIW, Rust gives the same result as Swift here: Try it online!

I guess that isn't surprising, though, Rust doesn't really have inheritance

New Sandboxed Posts

12:03 PM

0

A: Sandbox for Proposed Challenges

ABC triples Three positive integers A, B, C are ABC-triple if they are coprime, with A < B and satisfying the relation : A + B = C Examples : 1, 8, 9 is an ABC-triple since they are coprime, 1 < 8 and 1 + 8 = 9 6, 8, 14 is not because they are not coprime 7, 5, 12 is not because 7 > 5 You c...