Depends on #131 and #452

class Main {}
    class method run: cmd in: sys
        let c = C new.
        sys output println: "foo: {self foo: c} => I0 ok?".
        sys output println: "bar: {self bar: c} => I1 ok?".
        sys output println: "quux: {self quux: c} => I ok?"<ENTER>
end

Hitting where marked leaves emacs spinning until C-g.

Self hosted only

To be checked on initialization and method exit.

syntax sketch:

class Foo { a b }
    invariant: a < b
    ...
end

...again, following Hypothesis' lead.

Creating literal selector objects.

Methods:

• Block interface: #selector value: x --> x selector, allowing

  foo do: { |x| x selector } --> foo do: #selector
  

• #sendTo:, #sendTo:with:

See: https://github.com/DRMacIver/minithesis

Ie.

{ |x| foo x: x } == { foo x: _ }

(This is one of the more ambitious "good first issues" -- I would suggest doing this in self-hosted implementation only at first. My own plan is to postpone this until self-hosting is complete, but it can be done sooner.)

    method testRecord
        assert true: { let r = {x: -10, y: 52}.
                       r x + r y == 42 }
        testing: "record creation and accessors"

Should align testing: with true:

• design
• Filepath#file -> File
• File#forRead specifies readmode
• File#forWrite specifies writemode
• File#forAppend specifies appendmode
• File#truncateExisting specifies that existing file should be truncated
• File#open -> FileStream, requires file to exist
• File#create -> FileStream, requires file not to exist.
• File#createOrOpen -> FileStream, if file does not exist creates it

An exception is raised if no modes have been specified before open/create/createOrOpen.

Very similiar to #111, as such may require #359

Texmate grammar at least, or LSP, or maybe a JS implementation from #359?

class Main {}
    class method foo: x::Type
    x

Should be:

class Main {}
    class method foo: x::Type
        x

It should be possible to apply arrays to blocks:

{ |x y| x + y } apply: [40, 2] --> 42

class Foo {}
me<tab>

leaves 4 trailing space after me

Class representing Unicode codepoints / scalar values.

Methods should provide facilities similar to rust's char.

String should gain related methods as well.

Critically needed:

• isDigit
• isWhitespace
• digit

(and others like it)

Should be just Interval.

Happens on the interface branch, no does not yet affect master.

Alternatively I could take the Ruby route and allow methods like this:

method [key]
   ...

method [key] = value
   ...

The same approch would speak to my question, "what about function call syntax?":

method (x)
   ...
method (x,y)
   ...

Ie. run cargo fmt -- --check

Self-hosted only

assert forAll: Strings ...

A close parallel to case #101.

This means Class should also contain the class_vtable. This probably allows simplifications elsewhere too.

foo::Foo

Causes foo: to highlight as a keyword.

foo == bar

foo is highlighted as if it was a variable assignment, but should not be.

Depends on #98 being implemented first.

Usage something like:

assert forAll: (Arrays of: Integers) ...

• Have a look how Hypothesis generates its more complex objects.
• Figure out how to drive the lower-level generator.
• Implement it.

key -> value --> Association from: key to: value

Implement as operator or syntax?

Pro syntax:

• Cannot be overridden
• { a -> x } is a dictionary
• -> is already syntax in method signatures
• Support for destructuring possible: dict do: { |a -> b| ... }

Pro operator:

• less syntax, less special casing
• {} syntax is already wrought

Current thinking: syntax. Mainly because -> is already syntax instead of an operator.

But why is association syntax needed in the first place? ...that's a really good question. Maybe it's not needed right now after all.

Should require a define. (Fallout from environment refactoring.)

foo/toplevel_let.foo:

let X = 123

Then:

$ cargo run -- foo/repl.foo --use foo
    Finished dev [unoptimized + debuginfo] target(s) in 0.21s
     Running `target\debug\foolang.exe foo/repl.foo --use foo`
Foolang 0.2.0
> import foo.toplevel_let.X
"foo\toplevel_let.foo"
> X
123

Options:

• Pretend that's the way it's supposed to work.
• Make it not do that, and instead implement define.

• define syntax
• parser
• evaluator

Branch: interfaces

• define interface syntax
• define inheritance syntax
• parse into InterfaceDefinition with default methods
• parse required methods as well
• parse is in class as inheriting an interface
• eval_interfaces creates a vtable
• eval_class initializes the class vtable from inherited interfaces and reports conflicts
• handle required but unimplemented methods in eval_interface and eval_class
• make_class and make_interface ensure that overridden and defined methods have signatures that match interfaces
• typechecking understands interfaces
• extend allows adding interfaces to classes
• allow interfaces to inherit each other

• minimal design sketch & docs
• implementation
• tests

Question!

System files is not the same as current working directory. ...but we do need access to current working directory. Should there be System#currentDirectory that just returns the string? Or is that a FilePath too?

Depends on #52, #53, and #54. (Filesystem stuff.)

Hypothesis uses a database, need to think about this. OTOH, an SQLite interface would be a good thing to have anyhow...

• close
• flush
• isClosed
• isOpen
• size
• resize: size
• offset
• offset: absolute
• offsetFromEnd: relative
• offsetFromHere: relative
• readBytes
• readString
• read: n bytesInto: byteArray at: index
• write: n bytesFrom: byteArray at: index
• tryRead: n bytesInto: byteArray at: index
• tryWrite: n bytesFrom: byteArray at: index
• tryReadOnce: n bytesInto: byteArray at: index
• tryWriteOnce: n bytesFrom: byteArray at: index
• writeBytes: bytes
• writeString: string

Some options:

• Class method vs Class#method (space vs #)
  Probably: requires quoting in text as in: "Using List defaultCapacity one can..." vs "Using List defaultCapacity one can..."
• Class#classmethod vs class#instancemethod (casing)
  PROBABLY NO: doesn't work with lowercase classes, which I'm more inclined to allow now.
• Class##classmethod vs Class#method (# vs ##)
  MAYBE: not super intuitive -- could be the other way around as well
• Class>method vs Class>>method
• Class class>>method vs Class>>method

Decision for now: Class method and Class#method.

Note: requires very high quality indentation engine for this not to be terrible! Maybe #359 ?

Foolang 0.2.0
> [let x = 42. x+x, x]
[84, 42]
> x
42
> system exit

(Should give an unbound variable error for the third x inside the array -- let scope should end at the comma.)

I keep forgetting them myself...