I need to sleep now, but I started work on this repo for a lisp where strings and comments are the same thing. I've only done the parser yet, but I'm intending to make it transpile to Python and use comments to both generate and check code. Feel free to copy from it if y'all want, I need to go sleep now o/

(also, we really need to organize teams by timezone next langjam)

I'm here all day if anyone wants me to write something

sussy baka

if the point of comments is to be ignored

@AaronMiller ok, will do

all invited.

if i am right the repo is on @user gh account

the theme is "First class comments" lol

Aaaaahhhhhhhh

It started already!!!!!!

I totally forgotttttttt

@Razetime I'm offended :p

I highly recommend Lark as our (Python) parsing library. I have some experience with it, too

I want to add to this idea:

> Comments perform seach-and-replace to modify the running program.

Just want to point out that a very common comment syntax is

print("this is a command") //this is a comment

Where the // is suspiciously similar to /// in slashes

So that if we do this one, our syntax could be something like:

command args //find/replace

!IMPORTANT

First-class comments means comments can be assigned to variables, passed as parameters to functions, and returned from functions.

In other words, everything that you can do with a number or a string in Python, you should be able to do with comments in this language

That is, if we're going to follow the theme strictly

!</IMPORTANT>

oh

I'm clarifying that because there's hardly any ideas, if at all, in the list that seem to do that:

so parsing would be like a separate comment object

gist.github.com/AMiller42/fd89a8f75c92573f3b391d85b39e9108

And clearly the other team didn't realize either

Or whoever/whatever GPT-3 is

Right, comments should be an type native to the language

and you should be able to assign them, and return/pass in functions

Again, assuming we should interpret the theme literally

It's unclear how rigid the theme is

But that's what being a first-class object is

That's why, for instance, it's such a big deal that "LISP/Haskell has first-class functions"

Aka, "functional langs have first-class functions"

Nowadays, functions are close enough to first class in most scripting langs, like Python/Ruby

But that's a big deal coming from something like C/COBOL/PASCAL

So another way to think about it is that comments should be more native to our language, than functions are to C

Namely, you can't pass functions as parameters to other functions in those langs. Or return them from functions. (Higher-order functions)

Summing up: As I see it, our challenge is basically to have another string-y type which we're calling comments. But to have them somehow be different enough from strings that they're still interesting. And to have them still feel like comments, even though they're now a meaningful part of the language. We want to somehow preserve the spirit of comments, despite having them act more like strings.

Done ranting! Now must go to bed. Sorry I missed the beginning.

Go team us!!

o/

ok so comments are separate objects

which can be used like other objects

Right, but again, that's what it technically means to be a first-class citizen

It's looking like a lot of teams may not actually do it literally, so it may not end up being enforced

but how do we make the comment object interesting

also the comment should be delimeted by \\* and `*\`

I don't want us to blindly stick to the definition because I said so, and then have everyone else do other things, and then me=in-trouble, haha

@PyGamer0 Depends what we're using the comments for

Too early to tell

IDEA: One of the unique characteristics of comments is that they break up the code between them

Eg. print("hello") vs pri/*comment*/nt("hello")

or even vs print("he/*"roar"*/lo")

So re: comments being assignable, I'm wondering about having the assignment be the row/column that the comment goes in

And then you can sort of manipulate/swap comments and their positions/lengths/contents

The idea in this language then, would be to come up with a set of break-uppable primitives, which did different things depending on where they were broken up

And maybe also how long the stuff between them was, or what character was or wasn't between them (in the comments)

Perhaps this would be your only way to do conditionals

So programming in this lang would consists of having a basic structure set out of primitives, and then manipulating the comments at runtime

To strategically disrupt the flow of the program, and change the meaning of some of the commands

And also for conditionals/loops

Or perhaps, the program should loop forever by default

And the only way to halt it would be to comment/break-up everything

I like that!

So it'd keep looping through the file, repeating whatever runnable commands there were

Until it did a full pass with nothing left to run

so comments can manuplilate the code at runtime?

It'd be annoying to end up with looping code everytime you made a mistake, and harder to test and work with at the beginning though. So either way would be fine.

@PyGamer0 Yeah, that's your only way of manipulating the code at runtime

The program is just a static canvas

That you build just to disrupt with comments at runtime

Something like that anyway

Something about using the unique break-up-code property of comments

Instead of the unique documenting-stuff property of comments

I think it's a more creative idea and that way more people will already be doing the other 'use' of comments

@AviFS so `pri/*something*/nt("Hi!"), what will happen when we run this?

And it's also infinitely easier to do this

Because we don't have to worry about giving comments semantic meaning or parsing english/writing an english-based dsl for use in comments

@PyGamer0 Well nothing, we prob won't have print as a command

@AviFS That's why this

We'd have to come up with a clever set of primitives which were could be broken up in a way that you could sort of remember and makes sense

@AviFS then how would, say, a for loop that prints the first 10 natural numbers look like?

Whereas there's no way to remember what pri does

@PyGamer0 Not the slightest clue yet

I'm really just providing the idea of using breaking-up property rather than documenting stuff

so comments separate out commands? to make them into multiple commands?

And of moving them around in the code

@PyGamer0 Right

The extreme here would be to have something like binary

And each 3 bit sequence corresponds to a different command

Eg, we could just build this off the back of binaryfuck

Although it's not what I had in mind at the start

I was thinking slightly more 'nice' things

I was thinking stack-based with things like breaking up increment the top ++, to get +...+ add the top two elements twice

esolangs.org/wiki/Binaryfuck

But binaryfuck is simple, turing complete and easy to write an interpreter for

So it would allow us to spend all our symbols coming up with first-class ways to manipulate the comments

And I actually think it's the safest since we've already used 18% of our time :(

stack based esolang with comments manuplilating the code?

Yup

One other idea

Property: Another property of comments is that if you take them out, then the program still runs the same

Here's what basing the lang off this property might look like:

We have a stack based lang, with two stacks: primary and secondary. The lang starts with the primary stack.

@AviFS then how would it understand a separate command?

The beginning of a comment swaps stacks, and the end of a comment swaps stacks back

Both start/end of a comment swap stacks. That's the meaning of /* & */ in this lang

But the effect is that everything outside the 'comments' happens on the primary stack

And everything inside the comments happens on the secondary stack

So as long as you can't do any funny business moving back and forth, if you remove the 'comments' it looks like the program is still doing the same thing

The comments are just extranouse comments, we think

The trick?

Printing on the primary stack outputs to stdout

Printing on the secondary stack outputs to stderr

Oh

So it doesn't look like the output has changed either

Except it has...

switched streams?

The only difference in adding comments is that you can only error in a comment ; )

Hey @exedraj, two ideas here!!

Very cool

if i understood everything: gist

@AviFS ^?

so shall we start writing?

I made three convos, including one for each idea!

Langjam Conversations

I'm afraid I have to go to bed : (

oh so we need to decide what to do

Like super duper really duper

@PyGamer0 But yeah, that's perfect!

@AviFS no problem o/

@PyGamer0 I definitely think Out or Err? is the cleanest and easiest

And I think esp. with our timezone issues and everything, it'll take longer than we think and that we should get going

i think i am gonna ask others how complicated is their language on discord

I'm pretty sure one or a two end up people will end up doing the writing the last 60% of the code on their own, just to try and get something in on time

@PyGamer0 Often for jams people are together and in one place

And then they sleep very little & together, getting pizzas and stuff

ok but who should start writing

Or at least, that's what a hackathon is, lmao

@AviFS brackeys (if thats his name)

So they could totally be doing way complicated things depending on their organization

@Razetime look at the pinned messages

But given the first 8 hours, I think we just need to make it a priority to get something out

which of the 3 ideas? @Razetime?

Only thing is we absolutely can't get distracted with what stack lang primitives to have

@PyGamer0 why are you asking me to decide

We have to do very basic turing tarpit style primitives

@Razetime idk

ok

@AviFS copy everything from Vyxal

I'll make some things final.

And if anything, base on another langs primitives. But I think that's a bad idea because then it'll just look like we copied a language and added comment swapping

We are making a stack based, functional language where comments are not ignored.

It's a bad look

but comments are comments

@PyGamer0 Definitely not though. See above!

@Razetime ?

you're planning on making comments affect the rest of the code, no?

you can store, use, retrieve comments

You're doing a different idea, right?

no we're on the same team dummy

the consensus was functional and tacit tied

I mean a different idea from the two I proposed

of those two functional is relatively simpler

So is that what you're doing?

WE

are doing.

lmao

because we voted on it

That was before we knew the theme, though

Did you see the ideas above?

bruh lol\

yes, I did.

Lots of people have ideas in the gist

And I'm not sure functional/tacit fit in easily anymore

@Razetime lets use one of the ideas

Also, I don't think we have time to do that

function might fit(sort of)

here's an idea

I don't think we have time Raze

you must have a different language's code in your file

and the comments in that file are run as our language

We have lots of ideas, though

@Razetime uh as in polygot language

And given timezones and how many people

sort of.

Maybe we split up?

An idea like what commentator does

@AviFS we can't

Why not?

I don't think it's too late to 'register'

I'd be surprised given how unofficial

well I guess delete your PR if you want

so far me, you, pygamer, emanresu are the only people discussing

Oh really?

so if you want go ahead and create a one person team

@emanresuA isnt talingk

Well and Aaron Miller, right?

in a longer jam a big team would make sense

What? I never said a one person team

I mean, I could

who do you want on it

But I was just saying since we have lots of ideas we want to do

And lots of timezones

you have to end up on one idea anyway.

It's always a possibility to split up

not everyone will get work, obviously.

uuuhhh

yeah idk what is happening

And sometimes smaller teams work faster

If you want a separate team go ahead. nobody is stopping you

Because consensus requires less people

uh

@Razetime Did I annoy you?

no, not at all

I'm gonna go to bed for now, but I'll touch base tomorrow, and see where everything is

just be decisive instead of prolonging the discussion

A lot can happen in 12 hours. Best of luck team!

@Razetime That's pretty funny, I thought I was being decisive and you were prolonging

oOOOF

As far as I can see from the idea, I think out/err is the most (only) practical idea that we can feasibly finish

@PyGamer0 are you cool with implementing a scanner

Or a binaryfuck derivative with comments to change what bf the binary corresponded to

That's the idea above

please, no brainfuck derivatives.

But I'd really love to do someone else's idea

@Razetime wdymbt?

I just didn't see any others that seemed practical

@Razetime Here's the link to that idea

@PyGamer0 a scanner. It takes a string of text and separates it into the syntactical components of the language.

I already logread

It's anything but a bf derivative, though

@Razetime But then you wouldn't call it a bf-derivative

it is very mucha bf derivative

uh

That was the last couple comments in a 50min convo

@Razetime use lark?

And even that, I would not call a bf deriv

Plus, it's trivial to make the bits map onto a different lang

It's not about working with bf, it's about having a string of 1s & 0s, or other things

That you have to move around destructors to break up and put together in different ways

@PyGamer0 the syntax looks simple enough to make a manual scanner without much pain. use lark if you're finding it hard.

What syntax?

What are you guys working on?

your first idea

But you didn't like it?

looks C-like

But it isn't

@Razetime so the pinned one?

like they are objects

And what kind are you doing? Bytestring? Stack-based?

stack based is the easiest

There isn't even anything to lex yet except /* & */

go with that

@Razetime liek an esolang?

And I don't think stack-based is easiest honestly

Because then you have to choose the primitives

@PyGamer0 stack based doesn't make a language an esolang.

@AviFS what do you not have to choose primitives in?

Honestly, I recommend the second idea

And it's also stack-based, just for you :p

every language needs some design choices.

@Razetime no like an esolang or just expanded names for functions?

I think the idea is simple, elegant and clear

And the only thing to be done is to choose the primitives

this one?

That one

Or actually, I think I'll just put that one together in an hour and submit it separately

And then we can still work on the first one together

There's really nothing to do for the second one

so what happens if there an error outside of the comments?

@AviFS this is super simpple

@Razetime it goes to stdout?

@PyGamer0 Yeah, I'll do it separately

Back to the first one!

but errors can't be on stdout

will the program just halt without saying anything?

Says who?

or will the program keep running

Not totally decided, but I agree we should do the first one!

i am confused lol

Designing breakupabble primitives should be fun & interesting

If you guys start on that

@AviFS ok can you like put it in a word doc/pastebin somewhere

so we can pin it

I'll write the parser when I wake up

I made convos rememberrrrrr

ok which conversation is it then

ok now will comments always break up code?

Yup

or do we have escapes for preventing commenting out of sections

/**/ breaks it up

Though there should maybe be a simpler syntax for comments

just | as a comment start and endpoint?

it seems like people will mostly be using empty comments

Maybe hashes # at start/end

@Razetime yeah, but we want it to look like a comment, even if it isn't

so we should take advantage of existing syntax i think

because the only thing they're useful for is breaking up, no?

Yeah

But we want it to seem like comments

huh ok, # seems fine.

It's not an easy one though

The idea

who cares

ok my brother wants the computer

Because we still have to figure out what the syntax is for moving comments, how to do conditionals etc

so i am giving it to him

let's try doing something

So if you guys have a simpler idea along the way, you should def go for it

@AviFS maybe self modification to comment out sections of the code?

a conditional will just comment out the code that's not supposed to run

I think something like binaryfuck with comments is the only version of that idea that would be very feasible

@Razetime I really super have to go too, unfortunately

why bother about feasible

just get a nice idea down first

But I look forward to working on it tomorrow and seeing what you guys have!

then we can remove unfeasible parts

@Razetime I was saying I don't think the idea is one we'll finish in time

we probably won't finish anyway

I feel like we're not gonna have the pr in within 38 hours

That's what I mean

We should try to, I think

so instead of axing ideas for the deadline just make as much as possible in the deadline

yeah... i'm at 9 second timeouts

and then we can extend it later after langjam even

@Razetime Whatever you guys start working on, I'll be happy to contribute to!

It'd be fun and more rewarding for me personally, if it felt like we were racing to the finish line

But we don't have to take that approach

'Til soon!

This room was placed in timeout for 30 seconds; Chill

ok

@PyGamer0 if you actually did put the room in time out, it wouldn't have impacted anyone lok

*lol

@exedraj ?

@PyGamer0 ROs can still talk during timeout

oh

lol

get added

How bout I don't

bruh who is startinf?

/shrug

\_@_/

idk which idea; who is holding the repo and etc

\_._._/

@exedraj /_€_\

alright enough shrugging

@exedraj :●

develop more ideas for each idea if you don't know which one

Someone plz write the grammar in lark

@PyGamer0 Hi

I is back

Also I have not idea how to use Lark

@emanresuA looks very easy

also look at the massive transcript

I saw

Avi's doing the parser

If I can have the full spec, I can start working on example programs - HW, Fizzbuzz, 99 bottles of beer, deadfish interpreter, etc

@emanresuA hmm idk ask @Razetime / @AviFS

Can't, they're both asleep.

how come raze is alseep ?

Maybe not asleep

Hold on I'll go look at their sleep schedules.

lets just think first class comments

lets add different types of comments

like todo, amazing, info, random

and code