Meow Programming Language - Cat-themed Functional Language that Transpiles to Go on Meow Programming Language

Contributing to the Meow Programming Language

Mon, 01 Jan 0001 00:00:00 +0000

Thank you for your interest in contributing to the Meow Programming Language! This guide covers everything you need to know to get started.

Development Environment Setup

Prerequisites

Go 1.26+ — required (see go.mod)
stringer — for code generation of token type names

# Install stringer
go install golang.org/x/tools/cmd/stringer@latest

Clone and Build

git clone https://github.com/135yshr/meow.git
cd meow
go build ./cmd/meow

Run Tests

go test ./...

Build and Run

# Build the compiler
go build ./cmd/meow

# Run a .nyan program
go run ./cmd/meow run examples/hello.nyan

# Show transpiled Go code
go run ./cmd/meow transpile examples/hello.nyan

# Run tests
go test ./...

# Run tests verbose
go test ./... -v

# Static analysis
go vet ./...

# Update golden files (required when changing compiler output)
go test ./compiler/ -update

# Regenerate stringer output (after changing token types)
go generate ./...

Project Structure

flowchart LR
 subgraph meow[" meow/ "]
 direction TB
 subgraph cmd["cmd/meow/ — CLI entry point"]
 cmd_main["main.go"]
 end
 subgraph compiler["compiler/ — Pipeline orchestration + E2E tests"]
 comp_go["compiler.go"]
 comp_test["compiler_test.go"]
 end
 subgraph pkg["pkg/"]
 token["token/ — Token types, keywords, positions<br/>token.go, tokentype_string.go"]
 lexer["lexer/ — iter.Seq-based tokenizer<br/>lexer.go, lexer_test.go"]
 ast["ast/ — AST node definitions<br/>ast.go, types.go, walk.go"]
 parser["parser/ — Pratt parser (iter.Pull)<br/>parser.go, parser_test.go"]
 checker["checker/ — Type checker<br/>checker.go"]
 types["types/ — Type system definitions<br/>types.go"]
 codegen["codegen/ — AST → Go source generation<br/>codegen.go, codegen_test.go"]
 formatter["formatter/ — Code formatter<br/>formatter.go"]
 linter["linter/ — Code linter<br/>linter.go"]
 mutation["mutation/ — Mutation testing<br/>mutation.go"]
 end
 subgraph runtime["runtime/"]
 meowrt["meowrt/ — Core runtime: Value, operators, builtins<br/>value.go, operators.go, builtins.go, list.go"]
 file["file/ — File I/O (snoop, stalk)<br/>file.go"]
 http["http/ — HTTP client (pounce, toss, knead, swat, prowl)<br/>http.go"]
 testing["testing/ — Test framework (judge, expect, refuse, run)<br/>testing.go"]
 coverage["coverage/ — Statement coverage tracking<br/>coverage.go"]
 end
 examples["examples/ — Sample .nyan programs"]
 testdata["testdata/ — Golden file tests (.nyan + .golden)"]
 docs["docs/ — Documentation"]
 end

Adding a New Keyword

Add the token in pkg/token/token.go:

Meow Programming Language Release Notes

Mon, 01 Jan 0001 00:00:00 +0000

A summary of features and changes in each Meow Programming Language release, organized from newest to oldest.

Kitty (Struct) Types — PR #26

User-defined composite types with typed fields.

kitty Cat {
 name: string
 age: int
}

nyan nyantyu = Cat("Nyantyu", 3)
nya(nyantyu.name) # => Nyantyu

What’s new:

kitty keyword for struct definitions
Field definitions with name: type syntax
Constructor functions (call type name with positional args)
Field access with . notation
Structural equality for kitty instances
KittyStmt and KittyField AST nodes
Runtime Kitty value type with GetField method

Go-style Grouped Parameter Types — PR #25

Parameters can share type annotations using Go-style grouping:

Meow Programming Language Specification: Syntax, Types, Functions, and Pattern Matching

Mon, 01 Jan 0001 00:00:00 +0000

This document defines the syntax and semantics of the Meow Programming Language.

Meow is a cat-themed programming language that transpiles to Go. Source files use the .nyan extension and are encoded in UTF-8.

Notation

This specification uses Extended Backus-Naur Form (EBNF) for grammar productions:

Production = name "=" Expression "." .
Expression = Term { "|" Term } .
Term = Factor { Factor } .
Factor = name | literal | "(" Expression ")" | "[" Expression "]" | "{" Expression "}" .

[ ... ] denotes optional (0 or 1).
{ ... } denotes repetition (0 or more).
" ... " denotes terminal symbols.

Source Code Representation

Source code is UTF-8 encoded text in .nyan files. Newlines serve as statement terminators (semicolons are not used). The compiler processes a single .nyan file at a time.

Meow Programming Language Tutorial: Learn .nyan Syntax from Hello World

Mon, 01 Jan 0001 00:00:00 +0000

A step-by-step guide to learning the Meow Programming Language. Each section builds on the previous one and includes runnable .nyan examples.

Prerequisites

Go 1.26+ installed
Meow compiler installed (see Installation)

Verify your installation:

meow version

1. Hello, World!

Create a file called hello.nyan:

nya("Hello, World!")

Run it:

meow run hello.nyan

Output:

Hello, World!

nya is Meow’s print function. It prints its arguments separated by spaces, followed by a newline.

You can also build a native binary:

Effective Meow Programming Language: Idiomatic Patterns and Conventions

Mon, 01 Jan 0001 00:00:00 +0000

Idiomatic patterns and conventions for writing clean, consistent code in the Meow Programming Language.

Placeholder Names

Every language has its go-to stand-in names — the world at large reaches for foo, bar, and baz. In Meow, we have our own cast of characters:

Name	Role
Nyantyu	The first cat on the scene — your default placeholder
Tyako	The second — shows up when one name isn’t enough
Tyomusuke	The third — for when the gang’s all here

Use them in examples, tests, and documentation whenever you need throwaway names. Keeping these consistent makes .nyan code feel at home everywhere in the project.

Meow Programming Language Standard Library

Mon, 01 Jan 0001 00:00:00 +0000

This document describes all built-in functions and standard library packages available in the Meow Programming Language.

Built-in Functions (no `nab` required)

These functions are available globally in every .nyan program.

`nya(args...)`

Print values to standard output, separated by spaces, followed by a newline.

nya("Hello", "World") # => Hello World
nya(42) # => 42
nya([1, 2, 3]) # => [1, 2, 3]

Returns catnap.

`hiss(args...)`

Raise an error by panicking. Arguments are joined with spaces and prefixed with "Hiss! ".

Meow Programming Language Quick Reference

Mon, 01 Jan 0001 00:00:00 +0000

A complete reference of all keywords, operators, and syntax in the Meow Programming Language.

Keywords

Meow	Meaning	Example
`nyan`	Variable declaration	`nyan x = 42`
`meow`	Function definition	`meow add(a int, b int) int { bring a + b }`
`bring`	Return a value	`bring x + 1`
`sniff`	Conditional branch (if)	`sniff (x > 0) { ... }`
`scratch`	Else branch	`} scratch { ... }`
`purr`	Loop (range-based)	`purr i (10) { ... }`
`paw`	Lambda (anonymous function)	`paw(x int) { x * 2 }`
`nya`	Print values	`nya("Hello!")`
`lick`	Transform each element in a list (map)	`lick(nums, paw(x) { x * 2 })`
`picky`	Select elements matching a condition (filter)	`picky(nums, paw(x) { x > 0 })`
`curl`	Combine a list into a single value (reduce)	`curl(nums, 0, paw(a, x) { a + x })`
`peek`	Branch based on a value (pattern match)	`peek(v) { 0 => "zero", _ => "other" }`
`hiss`	Raise an error	`hiss("something went wrong")`
`gag`	Catch errors (try/recover)	`gag(paw() { risky() })`
`is_furball`	Check if a value is an error	`is_furball(result)`
`nab`	Import standard library package	`nab "http"`
`flaunt`	Export (reserved)	—
`yarn`	True (boolean literal)	`nyan ok = yarn`
`hairball`	False (boolean literal)	`nyan ng = hairball`
`catnap`	Nil (represents no value)	`nyan nothing = catnap`
`kitty`	Struct (composite type) definition	`kitty Cat { name: string }`

Type Keywords

Meow supports gradual static typing. Type keywords can annotate variables, function parameters, and return values.

Meow Programming Language vs Go: Side-by-Side Reference

Mon, 01 Jan 0001 00:00:00 +0000

A side-by-side reference for Go developers learning the Meow Programming Language. Meow transpiles to Go, so many concepts map directly.

Syntax Comparison

Concept	Go	Meow
Variable	`var x int = 42`	`nyan x int = 42`
Short variable	`x := 42`	`nyan x = 42`
Function	`func add(a, b int) int`	`meow add(a, b int) int`
Return	`return x`	`bring x`
If	`if x > 0 { }`	`sniff (x > 0) { }`
Else	`} else { }`	`} scratch { }`
Else if	`} else if x == 0 {`	`} scratch sniff (x == 0) {`
For (counting)	`for i := 0; i < n; i++`	`purr i (n)`
For (inclusive)	`for i := a; i <= b; i++`	`purr i (a..b)`
Lambda	`func(x int) int { return x*2 }`	`paw(x int) { x * 2 }`
Print	`fmt.Println(x)`	`nya(x)`
True	`true`	`yarn`
False	`false`	`hairball`
Nil	`nil`	`catnap`
Struct	`type Cat struct { ... }`	`kitty Cat { ... }`
Import	`import "net/http"`	`nab "http"`
Error	`errors.New("msg")`	`hiss("msg")`
Panic	`panic("msg")`	`hiss("msg")`
Recover	`defer func() { recover() }()`	`gag(paw() { ... })`

Detailed Examples

Variable Declaration

Go:

Meow Programming Language Compiler Internals

Mon, 01 Jan 0001 00:00:00 +0000

This document describes the internal architecture of the Meow Programming Language compiler for contributors who want to understand or modify the compilation pipeline.

Pipeline Overview

flowchart TD
 src[".nyan source"]
 lexer["Lexer<br/>pkg/lexer"]
 parser["Parser<br/>pkg/parser"]
 checker["Checker<br/>pkg/checker"]
 codegen["Codegen<br/>pkg/codegen"]
 gobuild["go build"]
 bin(["binary"])

 src --> lexer
 lexer -- "iter.Seq[Token]" --> parser
 parser -- "AST" --> checker
 checker -- "TypeInfo" --> codegen
 codegen -- "Go source" --> gobuild
 gobuild --> bin

The pipeline is orchestrated by compiler/compiler.go:

Meow Programming Language vs MeowLang and Other Cat-themed Languages

Mon, 01 Jan 0001 00:00:00 +0000

If you searched for “Meow language” or “MeowLang” and landed here, this page explains what the Meow Programming Language is, and how it relates to other projects that share a similar cat-themed name.

What is the Meow Programming Language?

The Meow Programming Language is a cat-themed functional programming language that transpiles .nyan source files into Go source code, which is then compiled to a native binary using the standard Go toolchain.

Sitemap - Meow Programming Language

Mon, 01 Jan 0001 00:00:00 +0000

Browse every page of the Meow Programming Language website. If you cannot find a page through navigation, this directory lists everything that is published.

Meow Programming Language - Cat-themed Functional Language that Transpiles to Go on Meow Programming Language

Contributing to the Meow Programming Language

Development Environment Setup

Prerequisites

Clone and Build

Run Tests

Build and Run

Project Structure

Adding a New Keyword

Meow Programming Language Release Notes

Kitty (Struct) Types — PR #26

Go-style Grouped Parameter Types — PR #25

Meow Programming Language Specification: Syntax, Types, Functions, and Pattern Matching

Notation

Source Code Representation

Meow Programming Language Tutorial: Learn .nyan Syntax from Hello World

Prerequisites

1. Hello, World!

Effective Meow Programming Language: Idiomatic Patterns and Conventions

Placeholder Names

Meow Programming Language Standard Library

Built-in Functions (no nab required)

nya(args...)

hiss(args...)

Meow Programming Language Quick Reference

Keywords

Type Keywords

Meow Programming Language vs Go: Side-by-Side Reference

Syntax Comparison

Detailed Examples

Variable Declaration

Meow Programming Language Compiler Internals

Pipeline Overview

Meow Programming Language vs MeowLang and Other Cat-themed Languages

What is the Meow Programming Language?

Sitemap - Meow Programming Language

Built-in Functions (no `nab` required)

`nya(args...)`

`hiss(args...)`