. and -L are not adequate. Ideas of where kitten should search:

• An environment variable such as KITTEN_LIBS
• The directory of the executable
• That plus /lib
• An environment variable KITTEN_HOME
• $KITTEN_HOME/lib

• __cat_text
• Relational operations, e.g., __eq_text

E.g. for apply and compose:

def apply (A... (A... -> B...) -> B...): __apply

The following typechecks but fails during interpretation:

def ; ([a] a -> [a]): prepend

([Char])[]
'a'; 'b';

Type of prepend:

def prepend (a [a] -> [a])

Error:

kitten: user error (Pattern match failure in do expression at lib/Kitten/Interpret.hs:90:5-14)

Vectors should allow local variables; should work in much the same way as functions.

"short intro" and "mailing list" -- the latter says no such list is available while the former yields a 404

• Vim
• Emacs
• TextMate
• Sublime Text

It ought to be possible to define a new word with the same name as another, such that the previous definition is available within the new one. Currently, duplicate definitions are simply ignored, not even flagged as errors.

Notes should come after the error they refer to. These groups should be sorted, with the notes also sorted within.

I'm sure several things about it are semantically wrong, and performance could likely be improved. Mapping and folding should have constant stack depth.

Should probably be a wrapper around an existing C library.

Types themselves should be better about tracking their provenance so that meaningful lines of reasoning can be presented in error messages.

__stdin
__stdout
__stderr
__get_line
__open_file
__close_file

Could also be done like Python did, as a stdio wrapper with the FFI.

• Suggest x.0 if x is a literal int where a float was expected.
• Suggest +. in x y + if x and y are both float.

In the interest of providing good editor support, there ought to be syntax for tagging arbitrary expressions with metadata, such as:

• Documentation
• Examples
• Synonyms
• Tests
• Types
• Input methods

The latter is particularly important for Unicode sources; every identifier that includes characters outside of those commonly found on a keyboard should include one or more ASCII-only input methods. There may be overlap between input methods.

These have much the same structure and it’s kind of a shame that the code is duplicated.

Leaving this unscheduled as I don’t know offhand how involved it’ll be.

Don’t just bail on the first one.

• Allow declaring foreign modules (dynamic libraries) and importing definitions
• Make foreign definitions transparently callable

When I try to build kitten on my Linux laptop, the build fails due to the following error:
make: ./dist/build/Kitten/kitten: Command not found.

__(inc|dec)_(int|float) really should be primitives for performance reasons down the line.

Currently this is not done, so programs can typecheck that will fail at runtime.

Word definitions cannot be mutually recursive because the latter word does not exist at the point of invocation in the first.

$ cat > mutually-recursive.kitten
define a [b]
define b [a]

$ ./kitten mutually-recursive.kitten
Undefined word "b"

Potential solutions include:

• Allowing forward declarations
• Delaying parsing of definition bodies
• Delaying resolution of word names

Capital identifiers denote types and type constructors; lowercase, words and type variables.

The title is self explanatory.

The Haskell sources should be built with cabal rather than the Makefile hackery we have now.

[1 2 +, 3 4 *] should be valid, as should the tuple equivalent.

Should probably be a wrapper around an existing C library.

t3386 is not as helpful as it could be.

-> is more mnemonic than \ and has the advantage of looking nicer with multiple variable declaration:

1 -> x
1 2 3 -> (a b c)

To C, probably.

Should accept an empty stack.

Currently, comparisons and arithmetic operations undergo non-extensible type promotions within the runtime. These ought to be moved into a standard prelude.

The current REPL builtins can't take any input, which means that a builtin like :type can't be implemented.

• Resolve names into sets of possible overloads
• Let the typechecker add this information back into the AST
• During typechecking, select the unique overload that typechecks

E.g.:

{
  def double (int -> int) { 2 * }
  5 double // no apply
}

• __set
• Rename __at to __get
• Relational operations

Map and Set in particular.

The value representation is just awful and needs to be substantially redone.

Currently all values are boxed, whether inside or outside quotations. That’s fine for now, because removing layers of indirection in general is going to be non-portable. However, as a simple optimisation we can eliminate boxing in homogeneous quotations of integers, floating-point numbers, and characters.

The Makefile does not seem to support parallel jobs. -j1 works fine; any other value has a chance of screwing things up.

It should be possible to write this function:

def trip (a a (a a -> a) -> (a & a & a)):
  -> { a b f }
  a b f@
  a b f@
  a b f@
  pair pair

But its type is:

∀r s a. r a a (s a a → s a) → r (a & a & a))

When it should be the rank-2:

∀r a. r a a (∀s. a a → s a) → r (a & a & a))

So the compiler complains because f is applied to different stack types.

Something about an inner function capturing locals from an enclosing function multiple levels up. To do:

• Come up with a minimal test case
• Add internal debugging modes to make this kind of thing easier to catch & fix in the future
• In debug mode, retypecheck terms after scoping

It doesn’t have to be the final thing. Reinstating tuples (with a new syntax) would be fine until proper structures get in.