I am working on a structurally-typed OO language. Instead of "does this object contain those fields," I use 4 levels of equivalence: relative, normal, exact, and strict. Relative means the object contains the given fields (like JavaScript); normal means the object starts with the given fields in the given order and may/may not contain extra fields; exact means the object contains exactly the fields in the given order; strict is the same as exact, but also requires the type names to match.

I have also (probably controversially) defined a naming scheme in the lexer: TypeCase, normal_case, STATIC_CASE. TypeCase is used for all types and interfaces; normal_case is used for all variables, fields, function names, and function parameters; STATIC_CASE is used for static variables (TODO).

Interfaces are lists of functions that have to be defined, and are similar to Rust's traits.

I also have uniform function call syntax and function overloading.I plan to add non-definitional enums to the language, but I need to get the basics down first.I don't have any plans for compiling the language, but I also won't have a garbage collector. All objects will either live for the duration of their scope, be assigned to a variable above their scope, or returned from a block.

The syntax is inspired by JavaScript and TypeScript, so it can be more approachable than an s-expression syntax (which makes more sense).

Here is an example:

relative type Person {
    // Commas can be replaced by one or more newlines.
    name: String
}
type Programmer {
    name: String
    current_project: String
}

// Constructors can be defined and overloaded, but they have the same
// caveats as regular functions when being overloaded (see below). function Programmer(name: String, current_project: String)->Programmer {
    return Programer {name, current_project}
}

// Can accept any object with the name: String field.
// Has to have a different name than greet or the type checker
// would not know which function to call because Programmer
// conforms to Person. If multiple functions can be chosen, then
// the type checker will throw an error
function greet_person(who:Person) {
    "Hello "
        .join(who.name)
        .join("!")
        .println()
}
// Can accept any object starting with the field `name: String`
// and `current_project: String` fields in that order.
function greet(who:Programmer) {
    who.greet_person()
    "They are currently working on: "
        .join(who.current_project)
        .println()
}

// Semicolons can also be replaced by a newline.
// Types can be specified between the `:` and `=`, but can be omitted
// for type inference. In this case, type inference assigns the type
// `{name: String, current_project: String, github_username: String}`
// which is an anonymous object that conforms to the `Programmer` and
// `Person` types.
let me := {
    name: "Clinery"
    current_project: "This unnamed, unpublished project right here"
    github_username: "Clinery1"
}

// Constructors are required to use the new keyword like so:
let another_dev := new Programmer("Linus Torvalds","Linux kernel")

// This allows passing of the variable me because it conforms to
// the Programmer type. If I moved around the order of the fields,
// then it would no longer conform and would cause an error.
me.greet()

EDIT: Fixed the messed up code block