WC is a toilet but v, and c are Unlambda operators

First Version

WC is a toilet but v, and c are Unlambda operators or WCTVCUO is a esoteric programming language by User:Yayimhere. There are four operators/symbols:

• [x] creates a "scope", a space which a rule must be obeyed. A value only enters a "scope" if the scoped value gets applied to the non "scoped" one. This rule is normally left completely empty, which makes the "scope" useless. Quotes are used around the word scope here to clarify it may not be fully congruent with the wider idea of a scope, but the author could not find a better term. Note that these rules are applied and checked before every step of executing the program.
• .x̅z̃ creates a function, that when applied to their third value y, will do the following:
  • If one or both diacritics are above a space, y will replace the leftmost space.
  • If both are filled by some value (note: this value may be a full on expression, in which the diacritic is put onto the leftmost `), the following will happen:
    • A global scope around the whole program is created, with the rule that any instance of the expression or single value x will be replaced with [y], with y's scope having the rule that if ever one or more instances of z is to come up within the scope, then that scope is transformed to a function that when applied to some value w, every instance of z is replaced with w, and normal execution of everything resumes.
• v: acts as its Unlambda equivalent.
• c: acts as its Unlambda equivalent.

Application is the same as Unlambda, using `.

Second Version

WC Flushes Following Arguments or WCFFA is an esoteric programming language made by User:Squidmanescape based on the esolang WCTVCUO since it was scrapped (though it has recently been reformulated/recreated by User:Yayimhere).

In this language, there are many changes to Unlambda to the point that it's nowhere near the same language.

Commands

• c and v work the same as in Unlambda
  • c takes in one argument and creates a continuation, a function which "goes back in time" from the future to when the continuation was created and makes the c function that created it return the continuation's argument from the future instead of what it normally would.
  • v takes one argument and returns v.
• the Unlambda command ` is replaced by , which serves the same functions
• the command w takes in a continuation and its argument and returns w
  • if there is no continuation after it, it does nothing
• the command .x̅yz̃ creates a named function x that acts upon the input z with the code y
  • this creates new named functions which can be named with any characters, including ones in existing functions
  • to be clear, the operator name has ¯ as the last combined character and input has ̃ as the last combined character, (these can be any character and can stack, but the last combined character is what determines input vs name)
  • if you want any characters immediately after the function to count as the input, you have to use a space with a nasalization sign combined with it ( ̃); otherwise, only the exact characters after the function will be used as input every time and will be taken out of the program after being used
  • it does not require , for its input
  • v and w output the operator name rather than their own when in the code part

Operations are done from the rightmost , to the leftmost. Named functions are defined from the leftmost . in a given line. Once the definition is read, the function definition and newline are removed, but the named functions they don't start acting until all of the instances of , are gone. Once everything else is simplified, the existing names start acting on each other, longest first, left to right. Every time , shows up in a contextually appropriate place, all of the ,'s have to disappear (right to left) before the named functions start working again. After this starts, every time . shows up in a contextually appropriate place, a new named function is created and delimited by newline.

See also

• Subtle cough