talktalk

talktalk is a programming language. It kind of looks like Swift or Rust or Go if you squint. I want it to feel familiar and cozy but still have a lot of modern power. Like an F1 car with those seats that massage your back (todo: fix this lousy metaphor).

Here are some goals:

Learning stuff

This is by far the biggest goal. I didn’t super understand all the ins and outs of compilers. I still don’t but at least I have a way to learn now. You shouldn't use talktalk. But you might enjoy perusing talktalk.

Fully typed everything

Types are cool.

As much type inference as possible

I don’t know if it's a good idea. It’s probably not. I just think it’s neat.

Familiar-ish syntax

Haskell/ML-y syntax is beautiful. I hate it.

Figure out nice syntax highlighting color schemes

I feel like making full programming language is the only way to do this, right? Right? Don't answer that.

Here are some non-goals:

Blazingly fast performance?

I mean I’m probably not gonna litter the codebase with sleeps but I’m allowed to if I want.

Trying to make everything perfectly sound and decidable?

Is this even possible? I feel like I saw a YouTube video that said it’s not.

Trying to get others to use it?

Why? PHP exists, you should probably use that.

--

How it works¹

First we lex the code into tokens. Then we parse the tokens into an AST. Then we resolve the names in the AST. Then we type check the AST and produce a TypedAST. Then we lower the TypedAST into our own lil IR. Then our lil IR is interpreted by a lil interpreter. There’s no trick to it, it’s just a simple trick!

At this point you’re cracking your knuckles saying "nice try, wise guy, but you’ll have to do better than that if you want me to adopt this at my fortune 500 company where I do a very good job and that is why they pay me the BIG bucks." Ok ok, call off your goons. Here’s some more detail².

Lexing

It's a pretty standard lexer as far as lexers go. It takes a string and turns it into tokens. Tokens have start/end positions and types like StringLiteral, Comma and more. Side note: I made token types a Rust enum with associated String values for things like string/int literals and I regret it. Should have just used the positions to get the lexeme content but live and learn and laugh and love and all of that.

Parsing

talktalk takes the tokens from lexing and uses a handwritten recursive descent parser (I think? I'm not good at genres) with some chris pratt precedence for expressions. Nothing too exciting here. At the end of this we have an AST.

Name Resolving

At this point we have an AST with things that have names. Like functions, variables, nominals (structs/enums), methods, etc. Those names are all strings. Since different names can be different things at different types, we give every named thing a unique number so we can tell the difference. Those numbers are called Symbols. I don't know if that's the right term but ¯\_(ツ)_/¯. Concretely this means replacing all of the Name::Raw(string) names in the AST with Name::Resolved(symbol, string).

Side note: I looked into using De Brujin indices for this but I wasn't sure how to pronounce it so I didn't.

The name resolution pass also builds a strongly-connected-components graph that helps the type checker check things in an order that deals with mutual recursion.

Type inference/checking

This is where I've spent like 90% of my time. Turns out there's a lot of history there. Who knew? Anyways I read a lot of papers and the /r/ProgrammmingLanguages subreddit and every post on [thunderseethe]'s blog like fifty times. Here's what's going on in the type checker.

• We take the SCC graph built during name resolution and iterate through different each group of binders[^3]. At the top level, we have
  • Nominal declarations (struct T {..}/enum T {..}) get defined in the type catalog, which is basically just a big ol' dictionary of dictionaries of dictionaries. It stores information like:
    • What nominals are defined?
    • What methods do nominals those have?
    • What conformances do they have? What are their associated types?
    • What type parameters (generics) do they have?
    • What properties do structs have?
    • What variants do enums have?
    • What effects exist?
  • Top level functions.

to be continued

--

At this point you’re rubbing your hands together thinking “mamma mia! I’m about to make a million smackaroos using talktalk!” Well you probably are. But before you start firing up your local AI coding buddy you should know what’s still not there yet.

IO

You can print to stdout! But that is literally it. This seems like something that would be nice to have! But we don't have it yet.

A "Standard" library

I mean there isn't an unstandard library either so I'm not sure why I put that in quotes. Anyway, don't expect to see familiar things like hashmaps, fancy algorithms (sorry al gore), serialization tools, etc. Or maybe I have added some of those things and not updated this website yet!

Explicit mutation

Right now everything is mutable. It's chaos. The sky is crumbling and all I have is a looney tunes umbrella.

Mutable Arrays

I haven't implemented push on array yet. You're probably a functional programmer with a cool leather jacket and ripped jeans and a backwards baseball cap who thinks mutability is for cats and dogs but I just thought I'd mention it.

Concurrency

But concurrency isn't parallelism! So does this mean there's parallelism? No, it does not.

Visibility modifiers

Everything public, all the time baby.

Documentation

None.

So anyway, maybe you can see what I meant by "don't use this, peruse this."

It has some types you may have heard of before.

123 // Ints
1.23 // Floats
true // Booleans
"Hello 🦉" // Strings
[1, 2, 3] // Arrays
(true, 123) // Tuples?
{ fizz: "buzz" } // Records??

Here, have some arithmetic.

2 * 3 + 4 / 2 // I can't do this in my head

Maybe you like assigning things. Like a variable?

let a = 1
let b = 2
let c = a + b
c // => 3

Here’s how functions look to define and call.

func add(x) {
	x + 1
}

add(1) // => 2 Wow. Imagine that

Maybe you like types? You can specify them if you want.

let a: Int = 1
let b: Float = 2.0
let c = a + b // Uh oh, type error!

They’ll be checked. But you can also not specify them and types will still be checked:

let a = 1
let b = 2.0
let c = a + b

We've got polymorphic functions.

func identity(x) { x }
identity(1.23) // => 1.23 (Float)
identity(true) // => true (Bool)

You could write the function above explicitly too.

// it's good to be explicit sometimes
func identity<T>(x: T) { x }

Maybe you like product types.

struct Person {
	let firstName: String
	let lastName: String

	func greet() {
		// Strings can be concat'd
		print("hi i'm " + self.firstName + " " + self.lastName)
	}
}

Person(firstName: "Pat", lastName: "N").greet()

We've got sum types too:

enum Response {
    case ok(String), redirect(String), other(Int)
}

enum Response {
    case ok(String), redirect(String), other(Int)
}

match Response.ok("success!") {
    .ok(string) -> string,
    .redirect(message) -> message,
    .other(code) -> "uh oh"
}

Ok what about protocols?

// Ok so we've got some different pet foods here
struct CatFood {}
struct DogFood {}

// And we've got a protocol `Named` that just knows how
// to get names of things.
protocol Named {
    func name() -> String
}

// Let's make the pet foods conform to Named
extend CatFood: Named {
    func name() { "tasty cat food" }
}

extend DogFood: Named {
    func name() { "tasty dog food" }
}

// So far so good, right? Ok now let's add a Pet protocol.
protocol Pet {
    // Protocols can have associated types with their own constraints.
    associated Food: Named

	// This protocol has one required method. It just returns
	// the associated type Food for this pet.
    func favoriteFood() -> Food

    // Protocols can specify default methods.
    func handleDSTChange() {
        print("what the heck where is my " + self.favoriteFood().name())
    }
}

// Ok so now we've got a Cat, which conforms to Pet
struct Cat {}

// We use `extend` blocks to mark conformances.
extend Cat: Pet {
    func favoriteFood() {
        CatFood()
    }
}

// And a Dog which conforms to Pet
struct Dog {}
extend Dog: Pet {
    func favoriteFood() {
        DogFood()
    }
}

// We can call the protocol's methods 
Cat().handleDSTChange()
Dog().handleDSTChange()

Check it out, we've got effects:

// Define an effect. Effect names have the prefix `'`
effect 'fizz(x: Int) -> Int

// Handles 'fizz for as long as handler is in scope
@handle 'fizz { x in
	// This effect doesn't do much, it just returns what it was passed
	continue x
}

// Define a function with effects. The effect list is in `'[]`. Effects
// can also be defined as `'_` and they'll be inferred.
func fizzes(x) '[fizz] {
	'fizz(x)
}

print(fizzes(123))

Ok so are effects just weird functions? I mean kind of? But you can also use them as exceptions:

effect 'throw(msg: String) -> Never

func boom(x) {
	@handle 'throw { msg in
		print("caught: " + msg)
		return true
	}

	if x == 0 {
		'throw("boom")
	}

	false // should not run
}

boom(0)