DreamBerd's features in real-world languages I've heard of or used, I may have missed some in Perl, Ruby, PHP, and others:

- Exclamation marks: behave like semicolons in most language (extras are allowed). In some languages like Ruby and Lisps, convention is to put exclamation marks at the end of mutating functions, and question marks at the end of predicates

- Declarations: C++ has constant variables and pointers, like `const int * const x`. JavaScript has `const` which lets you mutate the variable, and TypeScript has separate `const` and `readonly`.

- Naming: Lisps let you put punctuation in names, and see https://codegolf.stackexchange.com/questions/28786/write-a-p...

- Arrays: Lua and R have 1-based indexing and R coerces float indices to integers, though JavaScript's interpretation is arguably even worse (https://stackoverflow.com/a/6649444)

- When: Unless you count setters and reflection magic, (un)fortunately the only example is the joke language INTERCAL

- Lifetime: These aren't anything like Rust's lifetimes

- Installer: Some languages used to have bad installations but I believe this is mostly fixed now. But difficult project configuration is still a thing (nodejs bundlers, CMake, Gradle), as-is create-foo-app

- Loops: Loops don't technically exist in pure functional languages like Haskell (though `forM_` is basically a loop), and other functional languages like ML and Scheme usually discourage loops. Instead there is recursion

- Boolean: Applies to any language with implicit `null` and `undefined`. I'm sure JavaScript and even TypeScript devs have encountered actual bugs caused by a bool which was neither `true` nor `false`. Even languages with explicit null you'll occasionally see `Option<bool>`

- Arithmetic: I've never seen this feature, which is actually kind of sad because I actually kind of like it (not enough to give `+` priority over `*` though).

- Indents: No languages, but I've had my IDE suggest 3 idents when it got screwed up (e.g. newline and there is a space after my cursor)

- Equality: Taken from JavaScript. Some languages like C++ and Java also have `==` which you don't always want

- Function: I know there are languages which let you declare keywords with shorthand but I can't remember which ones, only certain command completions (e.g. `npm i` for `npm install`). I do know there are languages which let you omit syntax like HTML closing tags (which comes later) and languages which have the same syntax with extra keywords for legacy reasons (SQL)

- Dividing by Zero: Is literally undefined behavior for integers in some languages like C, and literally undefined in actual math. Otherwise, in every language I'm familiar with it either returns NaN or infinity (for floats) or throws an exception

- Strings: Lua and JavaScript let you use single and double quotes, Python lets you use triple quotes, many languages have quasi-quotes for interpolated strings, and some languages let you use arbitrary delimiters like Racket (https://beautifulracket.com/explainer/stringlike-types.html#...)

- String interpolation: Most languages use ${}, Swift uses \(), some use just {} or #{}

- Types: C, Haskell, Java, and JavaScript treat strings as an array of characters (even though UTF-8 strings technically aren't), and Scheme and Haskell have arbitrary-precision numbers as the default. Python and TypeScript type annotations don't always work and aren't fully checked, as are Typed Racket's but Typed Racket is getting better at this

- Regular expressions to narrow string values: Not arbitrary regular expressions, but TypeScript's template literal types are close (https://www.typescriptlang.org/docs/handbook/2/template-lite...). Different languages and libraries name their regular expression type Regex, RegExp, and Regexp

- Previous and next: None. Though after does exist in a way (`defer` in some langauges)

- File structure: None, except Java requires one class per file, and most languages enforce that file structure matches package structure although some don't (e.g. TypeScript)

- Export: None, most languages let you control exports with either `export`, visibility modifiers, or separate header / implementation files, though some don't let you control exports at all and only "suggest" with underscores (e.g. Python). Rust even lets you set visibility to certain crates, which is a bit like DreamBerd's `export`, except only limited to super-crates because you must ensure that your symbol is visible in the create it's defined

- Class: Almost every language has classes, though some languages like Rust and Haskell have typeclasses which are different than OOP classes. The exceptions like C have "ad-hoc" classes for large projects, and ML has modules which are like classes but explicit (although OCaml has classes too!) Every language lets you create multiple instances of classes, but singletons and the factory pattern are very common in Java and also sometimes C++.

- Now: `Date.now()` is literally defined, in most languages, and nearly every language will let you get the current time in some way (even if behind a monad)

- Delete: `delete` and its equivalent let you delete quite a lot. In R you can delete local variables and then they will no longer be defined; you can delete keywords because they're actually functions which use R's weird evaluation rules; and you can access environments of other functions and delete their local variables, causing the function to break with "`x` not found". See this (https://stat.ethz.ch/R-manual/R-devel/library/base/html/rm.h...), which even has "remove everything in the global scope" as an example

- Overloading: Name shadowing is possible in most languages, and Rust lets you shadow variables directly like in the example. Personally I like this though, because 99% of the time when I redefine a variable with the same name, I intend to no longer use the old variable.

- CSS also has the `!important` rule which lets you prioritize overloads, and with nested selectors almost resembles DreamBerd's `!` prioritization.

- Signals: In JavaScript and they are quite confusing, The split function version (`getFoo()` / `setFoo(newValue)`) is in React useState and Solid.js, and the `value` setter with implicit getter (`foo.value` or `foo` in JSX, `foo.value = newValue`) is in preact. I believe the single function version (`foo()` / `foo(newValue)`) is in some library but I'm not sure which, I do know `setValue` can take a function with the previous value.

- AI: Automatic semicolon insertion is in JavaScript, and automatic closer insertion is in HTML. Most modern languages convert automatic insertion into syntax errors with quick fixes

- Copilot: If you write a more esoteric language like Coq, Copilot won't really understand your code either. Though it will understand the syntax and common parts, only suggestions will be worse than usual

- Ownership: The Rust foundation had a fiasco with their trademark proposal, though they've apologized and hopefully it's not going to be an issue in the next proposal

- Compiling: Most languages can compile most programs. However C++'s parsing is literally undecidable (https://blog.reverberate.org/2013/08/parsing-c-is-literally-...), as is TypeScript's type system (https://github.com/microsoft/TypeScript/issues/14833).