basicTypesBundle.grace

dialect "none"
import "intrinsic" as intrinsic

trait open {

    type None = intrinsic.noneType  // the interface type with all possile methods

    type Type = EqualityObject & interface {
        // a type is a disjunction of interfaces
        name → String           // the name of this type
        typeParameterNames → Sequence⟦String⟧
        isNone → Boolean        // true for the type None, otherwise false
        matches (value:Object) → Boolean
        & (other:Type) → Type    // answers the join (Self & other)
        | (other:Type) → Type    // answers the variant type (Self | other)
 //       :> (other:Type) → Boolean     // other conforms to self       ToDo: implement this!
 //       <: (other:Type) → Boolean     // self conforms to other       ToDo: implement this!
 //       :=: (other:Type) → Boolean    // (self <: other) && (other :> self)       ToDo: implement this!
        == (other:Type) → Boolean     // object identity
        ≠ (other:Type) → Boolean     // object non-identity
        - (other:Interface) → Interface     // the type that is like self,
            // but excluding other.methodNames from all self's interfaces
        hash → Number
        interfaces → Sequence⟦Interface⟧
        isType → Boolean        // answers true (and false for patterns that are not types)
        isInterface → Boolean   // answers true for interface types (and false other types)
        prefix ¬ → Pattern      // answers a pattern that's the inverse of this type
    }

    type Interface = Type & interface {
        // An interface is also a type: the type with self as its sole interface.
        // Hence, its `interfaces` method must answer [ self ]
        methodNames → Sequence⟦String⟧  // sorted sequence of the canonical
                                       // names of the methods in this interface
        methodAt(canonicalName:String) → Signature
            // argument is the canonical name of a method; answers its signature
    }

    type Signature = interface {
        name → String                       // the canonical name of the method
        typeParameterNames → Sequence⟦String⟧ // the names of the type parameters
        parameterNames → Sequence⟦String⟧   // the names of the parameters, in order
        parameterTypes → Sequence⟦Type⟧     // the types of the parameters, in order
        returnType → Type                   // the type of the result
    }

    type Object = interface {
        asString → String
        asDebugString → String
    }

    type Done = interface {
        asString → String
        asDebugString → String
    }

    type Boolean =  EqualityObject & interface {
        not → Boolean
        prefix ! → Boolean
        // the negation of self

        && (other: Predicate0 | Boolean) → Boolean
        // returns true when self and other are both true

        || (other: Predicate0 | Boolean) → Boolean
        // returns true when either self or other (or both) are true

        ifTrue (action:Function0⟦T⟧) → Done forall T
        // if self is true, executes action
        ifFalse (action:Function0⟦T⟧) → Done forall T
        // if self is false, executes action

        ifTrue(trueAction:Function0⟦T⟧) ifFalse(falseAction:Function0⟦F⟧) → T | F forall T, F
        // if self is true, executes trueAction; otherewise, executes falseAction.
        // Answers the result of the action that was executed

        ifFalse(falseAction:Function0⟦F⟧) ifTrue(trueAction:Function0⟦T⟧) → T | F forall T, F
        // if self is false, executes falseAction; otherewise, executes trueAction.
        // Answers the result of the action that was executed

        asString → String
        asDebugString → Unknown
        // answers thes string "true" or "false"

        hash → Number
        // the hash of this boolean; true.hash ≠ false.hash
    }

    type Pattern = Object & interface {
        matches(value:Object) → Boolean
        & (other:Pattern) → Pattern
        | (other:Pattern) → Pattern
        prefix ¬ → Pattern
        isType → Boolean
    }

    type Binding⟦K,T where T <: EqualityObject⟧ = EqualityObject & interface {
        key → K
        value → T
    }

    type EqualityObject = Object & interface {
        ::(o:Object) → Binding
        ==(other:Object) → Boolean
        ≠(other:Object) → Boolean
        hash → Number
        prefix == → Pattern
        prefix ≠ → Pattern
    }

    type ExceptionKind = EqualityObject & Pattern & interface {
        refine (parentKind:ExceptionKind) → ExceptionKind
        parent → ExceptionKind
        name → String
        raise (message:String) → Done
        raise (message:String) with (argument:Object) → Done
    }

    type ExceptionPacket = Object & interface {
        exception → ExceptionKind   // the exceptionKind that raised this exception.
        message → String            // the message provided when this exception was raised.

        data → Object               // the data object associated with this exception
                                    // when it was raised, if there was one. Otherwise,
                                    // the string "no data".

        line → Number               // the source-code line of the raise request
                                    // that created this exception.

        moduleName → String         // the name of the module containing the raise
                                    // request that created this exception.

        backtrace → Sequence⟦String⟧
        // a description of the call stack at the time that this exception was raised.
        // backtrace.first is the initial execution environment; backtrace.last is the
        // context that raised the exception.

        printBacktrace → Done       // writes a readable description of this
                                    // exceptionPacket and its backtrace to io.error

        printBacktraceSkippingModules(skipable:Collection) → Done
                                    // like printBacktrace, but omiting those stackframes
                                    // representing modules in skipable

        reraise → None              // raise this exceptionPacket again
    }

    type Function0⟦ResultT⟧  = Object & interface {
        apply → ResultT     // Function with no arguments and a result of type ResultT
    }
    type Function1⟦ArgT1, ResultT⟧ = Object & interface {
        apply(a1:ArgT1) → ResultT       // Function with argument a1 of type ArgT1,
                                        // and a result of type ResultT
        matches(a1:Object) → Boolean    // answers true if a1 <: ArgT1
    }
    type Function2⟦ArgT1, ArgT2, ResultT⟧ = Object & interface {
        apply(a1:ArgT1, a2:ArgT2) → ResultT
            // Function with arguments of types ArgT1 and ArgT2, and a result of type ResultT
        matches(a1:Object, a2:Object) → Boolean
            // answers true if a1 <: ArgT1 and a2 <: ArgT2
    }
    type Function3⟦ArgT1, ArgT2, ArgT3, ResultT⟧  = Object & interface {
        apply(a1:ArgT1, a2:ArgT2, a3:ArgT3) → ResultT
        matches(a1:Object, a2:Object, a3:Object) → Boolean
            // answers true if a1 <: ArgT1 and a2 <: ArgT2 and a3 :< ArgT3
    }

    // Procedures are functions that have no result (oterh than Done)
    type Procedure0 = Function0⟦Done⟧
        // Function with no arguments and no result
    type Procedure1⟦ArgT1⟧ = Function1⟦ArgT1, Done⟧
        // Function with 1 argument of type ArgT1, and no result
    type Procedure2⟦ArgT1, ArgT2⟧ = Function2⟦ArgT1, ArgT2, Done⟧
        // Function with 2 arguments of types ArgT1 and ArgT2, and no result
    type Procedure3⟦ArgT1, ArgT2, ArgT3⟧ = Function3⟦ArgT1, ArgT2, ArgT3, Done⟧

    // Predictates are functions that return a Boolean
    type Predicate0 = Function0⟦Boolean⟧
        // Function with no arguments returning Boolean
    type Predicate1⟦ArgT1⟧ = Function1⟦ArgT1, Boolean⟧
        // Function with 1 argument of type ArgT1, returning Boolean
    type Predicate2⟦ArgT1, ArgT2⟧ = Function2⟦ArgT1, ArgT2, Boolean⟧
        // Function with 2 arguments of types ArgT1 and ArgT2, returning Boolean
    type Predicate3⟦ArgT1, ArgT2, ArgT3⟧ = Function3⟦ArgT1, ArgT2, ArgT3, Boolean⟧
        // Function with 3 arguments of types ArgT1, ArgT2, and ArgT3, returning Boolean

    type String = EqualityObject & interface {
        reverseTimesNumber(n:Number) → String
        // answers self * n.  (Used by numbers to implement number * String)

        * (n: Number) → String
        // returns a string that contains n repetitions of self, so "Abc" * 3 = "AbcAbcAbc"

        ++(other: Object) → String
        // returns a string that is the concatenation of self and other.asString

        < (other: String)
        // true if self precedes other lexicographically

        <= (other: String)
        // (self == other) || (self < other)

        > (other: String)
        // true if self follows other lexicographically

        >= (other: String)
        // (self == other) || (self > other)

        at(index: Number) → String
        // returns the character in position index (as a string of size 1); index must be an integer in
        // the range 1..size

        first → String
        // returns the first character of self, as a String of size 1; self must not be empty

        second → String
        // returns the second character of self, as a String of size 1; requires self.size ≥ 2

        third → String
        // returns the third character of self, as a String of size 1; requires self.size ≥ 3

        fourth → String
        // returns the fourth character of self, as a String of size 1; requires self.size ≥ 4

        fifth → String
        // returns the fifth character of self, as a String of size 1; requires self.size ≥ 5

        last → String
        // returns the last character of self, as a String of size 1; self must not be empty

        allSatisfy(p:Predicate1⟦String⟧) → Boolean
        // answers true iff all the characters in self satisfy the predicate p

        anySatisfy(p:Predicate1⟦String⟧) → Boolean
        // answers true iff any one of the characters in self satisfies the predicate p

        asDebugString → String
        // returns self enclosed in quotes, and with embedded special characters quoted.  See also quoted.

        asLower → String
        // returns a string like self, except that all letters are in lower case

        asNumber → Number
        // attempts to parse self as a number;  returns that number, or NaN if it can't.

        asUpper → String
        // returns a string like self, except that all letters are in upper case

        do(action:Procedure1⟦String⟧) → Done
        // applies action to each character of self.

        do(action:Procedure1⟦String⟧) separatedBy(sep:Procedure0) → Done
        // applied action to each character of self, and applies sep between actions.

        capitalized → String
        // returns a string like self, except that the initial letters of all words are in upper case

        compare (other:String) → Number
        // a three-way comparison: -1 if (self < other), 0 if (self == other), and +1 if (self > other).
        // This is useful when writing a comparison function for sortBy

        contains (other:String) → Boolean
        // returns true if other is a substring of self

        endsWith (possibleSuffix: String)
        // true if self ends with possibleSuffix

        filter (predicate: Function1⟦String,Boolean⟧) → String
        // returns the String containing those characters of self for which predicate returns true

        fold⟦U⟧ (binaryFunction: Function2⟦U,String,U⟧) startingWith(initial: U) → U
        // performs a left fold of binaryFunction over self, starting with initial.
        // For example, fold {a, b → a + b.ord} startingWith 0 will compute the sum
        // of the ords of the characters in self

        indexOf (pattern:String) → Number
        // returns the leftmost index at which pattern appears in self, or 0 if it is not there.

        indexOf⟦W⟧ (pattern:String) ifAbsent (absent:Function0⟦W⟧) → Number | W
        // returns the leftmost index at which pattern appears in self; applies absent if it is not there.

        indexOf (pattern:String) startingAt (offset) → Number
        // like indexOf(pattern), but returns the smallest index ≥ offset, or 0 if pattern is not found.

        indexOf⟦W⟧ (pattern:String) startingAt(offset) ifAbsent (action:Function0⟦W⟧) → Number | W
        // like the above, except that it returns the result of applying action if there is no such index.

        indices → Sequence⟦Number⟧
        keys → Sequence⟦Number⟧
        // an object representing the range of indices of self (1..self.size).

        isEmpty → Boolean
        // true if self is the empty string

        iterator → Iterator⟦String⟧
        // an iterator over the characters of self

        keysAndValuesDo(action:Function2⟦Number, String, Done⟧) → Done
        // applies action to two arguments for each character in self: the key (index) of the character,
        // and the character itself.

        lastIndexOf (sub:String) → Number
        // returns the rightmost index at which sub appears in self, or 0 if it is not there.

        lastIndexOf (sub:String) startingAt (offset) →  Number
        // like the above, except that it returns the rightmost index ≤ offset.

        lastIndexOf⟦W⟧ (sub:String) ifAbsent (absent:Function0⟦W⟧) → Number | W
        // returns the rightmost index at which sub appears in self; applies absent if it is not there.

        lastIndexOf⟦W⟧ (sub:String)
           startingAt (offset)
           ifAbsent (action:Function0⟦W⟧) →  Number | W
        // like the above, except that it returns the rightmost index ≤ offset.

        map⟦U⟧ (function:Function1⟦String,U⟧) → Collection⟦U⟧
        // returns a Collection containing the results of successive applications of function to the
        // individual characters of self. Note that the result is not a String, even if type U happens to be String.
        // If a String is desired, use fold (_) startingWith "" with a function that concatenates.

        ord → Number
        // a numeric representation of the first character of self, or NaN if self is empty.

        replace (pattern:String) with (new:String) → String
        // a string like self, but with all occurrences of pattern replaced by new

        size → Number
        // returns the size of self, i.e., the number of characters it contains.

        sizeIfUnknown⟦W⟧(action:Procedure0⟦W⟧) → Number
        // returns the size of self, which is always known, so action is never executed.

        split(splitter:String) → Sequence⟦String⟧
        // answers a sequence of substrings of self, split before and after each
        // occurrence of splitter in self.  If self is empty, the result sequence
        // will also be empty; otherwise, if self does not contain splitter,
        // the result sequence will be of size 1.

        startsWith (possiblePrefix:String) → Boolean
        // true when possiblePrefix is a prefix of self

        startsWithDigit → Boolean
        // true if the first character of self is a (Unicode) digit.

        startsWithLetter → Boolean
        // true if the first character of self is a (Unicode) letter

        startsWithPeriod → Boolean
        // true if the first character of self is a period

        startsWithSpace → Boolean
        // true if the first character of self is a (Unicode) space.

        substringFrom (start:Number) size (max:Number) → String
        // returns the substring of self starting at index start and of length max characters,
        // or extending to the end of self if that is less than max.  If start = self.size + 1 or
        // stop < start, the empty string is returned.   If start is outside the range
        // 1..self.size+1, BoundsError is raised.

        substringFrom (start:Number) to (stop:Number) → String
        // returns the substring of self starting at index start and extending
        // either to the end of self, or to stop.    If start = self.size + 1, or
        // stop < start, the empty string is returned.   If start is outside the range
        // 1..self.size+1, BoundsError is raised.

        substringFrom (start:Number) → String
        // returns the substring of self starting at index start and extending
        // to the end of self.    If start = self.size + 1, the empty string is returned.
        // If start is outside the range 1..self.size+1, BoundsError is raised.

        trim → String
        // a string like self except that leading and trailing spaces are omitted.

        quoted → String
        // returns a quoted version of self, with internal characters like " and \ and newline escaped,
        // but without surrounding quotes.  See also asDebugString

        >> (target:Sink⟦String⟧) → Collection
        // returns target << self

        << (source:Collection⟦String⟧) → String
        // returns a string containing me, followed in order by the elements of source.

        prefix < → Pattern  // the pattern matching strings < self
        prefix > → Pattern  // the pattern matching strings > self
        prefix ≤ → Pattern  // the pattern matching strings ≤ self
        prefix ≥ → Pattern  // the pattern matching strings ≥ self
        // prefix == is defined in the equality trait
    }

    type Collection⟦T⟧ = Object & interface {
        // Note that Collection does not include :: or hash, so collections
        // cannot be used as keys in dictionaries (although Sequences can).
        // In general, a collection may be mutable; Lists are, but Sequences are not.

        iterator → Iterator⟦T⟧
            // the iterator on which I am based
        isEmpty → Boolean
            // true if I have no elements
        size → Number
            // my size (the number of elements that I contain);
            // may raise SizeUnknown.
        sizeIfUnknown(action: Function0⟦Number⟧)
            // my size; if not known, then the result of applying action
        == (other) → Boolean
            // other and self have the same size, and contain the same elements.
        ≠ (other) → Boolean
            // other and self do not contain the same elements.
        first → T
            // my first element; raises BoundsError if I have none.
        do (body: Procedure1⟦T⟧) → Done
            // an internal iterator; applies body to each of my elements
        do (body:Procedure1⟦T⟧) separatedBy(separator:Procedure0) → Done
            // an internal iterator; applies body to each of my elements, and applies separator in between
        ++ (other: Collection⟦T⟧) → Collection⟦T⟧
            // returns a new Collection over the concatenation of self and other
        fold (binaryFunction:Function2⟦T, T, T⟧) startingWith(initial:T) → T
            // the left-associative fold of binaryFunction over self, starting with initial
        map⟦U⟧ (function:Function1⟦T, U⟧) → Collection⟦U⟧
            // returns a new collection that yields my elements mapped by function
        filter (condition:Predicate1⟦T⟧) → Collection⟦T⟧
            // returns a new collection that yields those of my elements for which condition holds
        contains (elem:T) → Boolean
            // returns true if elem is one of my elements
        anySatisfy (condition:Predicate1⟦T⟧) → Boolean
            // returns true if I contain an element e such that condition.apply(e) holds
        allSatisfy (condition:Predicate1⟦T⟧) → Boolean
            // returns true all of my elements e are such that condition.apply(e) holds
        >> (target: Sink⟦T⟧) → Collection⟦T⟧
            // returns target << self; used for writing pipelines
        << (source: Collection⟦T⟧) → Collection⟦T⟧
            // returns self ++ source; used for writing pipelines
    }

    type Number = EqualityObject & interface {
        @ (other: Number) → Point
        // answers a point with self as the x-coordinate, and other as the y-coordinate

        ^ (n: Object) → Number
        // answers self raised to the power n, if n is a Number.
        // Otherwise, answers n.reversePowerNumber(self)

        sqrt → Number
        // answers the square root of self

        + (n: Object) → Number
        // sum of self and n, if n is a Number.
        // Otherwise, answers n.reversePlusNumber(self)

        - (n: Object) → Number
        // difference of self and n, if n is a Number.
        // Otherwise, answers n.reverseMinusNumber(self)

        * (n: Object) → Number
        // product of self and n, if n is a Number.
        // Otherwise, answers n.reverseTimesNumber(self)

        / (n: Object) → Number
        // quotient of self divided by n (in general, a fraction), if n is a Number.
        // Otherwise, answers n.reverseDivideNumber(self)

        % (n: Object) → Number
        // if n is a Number, answers the remainder r after integer division of
        // self by n, where 0 ≤ r < self;  see also ÷.
        // If n is not a Number, answers n.reverseRemainderNumber(self)

        ÷ (n: Object) → Number
        // quotient q of self after integer division by n, if n is a Number:
        // self = (n * q) + remainder, where remainder = (self % other)
        // If n is not a Number, answers n.reverseQuotientNumber(self)

        .. (last: Number) → Sequence⟦Number⟧
        // the Sequence of numbers from self to last, so 2..4 contains 2, 3, and 4

        downTo(last:Number) → Sequence⟦Number⟧
        // the Sequence of numbers from self down to last, so 2.downTo 0 contains 2, 1 and 0.

        < (other: Number) → Boolean
        // true iff self is less than other

        <= (other: Number) → Boolean
        // true iff self is less than or equal to other

        > (other: Number) → Boolean
        // true iff self is greater than other

        >= (other: Number) → Boolean
        // true iff self is greater than or equal to other

        prefix - → Number
        // negation of self

        compare (other:Number) → Number
        // a three-way comparison: -1 if (self < other), 0 if (self == other), and +1 if (self > other).
        // This is useful when writing a comparison function for sortBy

        inBase (base:Number) → String
        // a string representing self as a base number (e.g., 5.inBase 2 = "101")

        asString → String
        // returns a string representing self rounded to six decimal places

        asDebugString → String
        // returns a string representing self with all available precision

        asStringDecimals(d) → String
        // returns a string representing self with exactly d decimal digits

        isInteger → Boolean
        // true if number is an integer, i.e., a whole number with no fractional part

        truncated → Number
        // number obtained by throwing away self's fractional part

        rounded → Number
        // whole number closest to self

        floor → Number
        // largest whole number less than or equal to self

        ceiling → Number
        // smallest whole number greater than or equal to self

        abs → Number
        // the absolute value of self

        sgn → Number
        // the signum function: 0 when self == 0, -1 when self < 0, and +1 when self > 0

        isNaN → Boolean
        // true if this Number is not a number, i.e., if it is NaN.  For example, 0/0 returns NaN

        isEven → Boolean
        // true if this number is even

        isOdd → Boolean
        // true if this number is odd

        sin → Number
        // trigonometric sine (self in radians)

        cos → Number
        // cosine (self in radians)

        tan → Number
        // tangent (self in radians)

        asin → Number
        // arcsine of self (result in radians)

        acos → Number
        // arccosine of self (result in radians)

        atan → Number
        // arctangent of self (result in radians)

        lg → Number
        // log base 2 of self

        ln → Number
        // the natural log of self

        exp → Number
        // e raised to the power of self

        log10 → Number
        // log base 10 of self

        prefix > → Pattern
        // a pattern that matches all numbers > self

        prefix ≥ → Pattern
        // a pattern that matches all numbers ≥ self

        prefix < → Pattern
        // a pattern that matches all numbers < self

        prefix ≤ → Pattern
        // a pattern that matches all numbers ≤ self

        prefix == → Pattern
        // a pattern that matches all numbers == self
    }

    type Point =  EqualityObject & interface {

        x → Number
        // the x-coordinates of self

        y → Number
        // the y-coordinate of self

        == (other:outer.Object) → Boolean
        // true if other is a Point with the same x and y coordinates as self.

        + (other:Point|Number) → Point
        // if other is a Point, returns the Point that is the vector sum of self
        // and other, i.e. (self.x+other.x) @ (self.y+other.y).  If other is a Number,
        // returns the point (self.x+other) @ (self.y+other)

        - (other:Point|Number) → Point
        // if other is a Point, returns the Point that is the vector difference of
        // self and other, i.e. (self.x-other.x) @ (self.y-other.y). If other is a
        // Number, returns the point (self.x-other) @ (self.y-other)

        prefix - → Point
        // the negation of self

        * (factor:Number) → Point
        // this point scaled by factor, i.e. (self.x*factor) @ (self.y*factor)

        / (factor:Number) → Point
        // this point scaled by 1/factor, i.e. (self.x/factor) @ (self.y/factor)

        length → Number
        // distance from self to the origin

        distanceTo(other:Point) → Number
        // distance from self to other

        dot (other:Point) → Number
        ⋅ (other:Point) → Number
        // dot product of self and other: (self.x * other.x) + (self.y + other.y)

        norm → Point
        // the unit vector (vecor of length 1) in same direction as self

        reverseTimesNumber(n:Number) → Point       // for double-dispatch; answers (n * x)@(n * y)
        reversePlusNumber(n:Number) → Point        // for double-dispatch; answers (n + x)@(n + y)
        reverseDivideNumber(n:Number) → Point      // for double-dispatch; answers (n / x)@(n / y)
        reverseMinusNumber(n:Number) → Point       // for double-dispatch; answers (n - x)@(n - y)
    }

    type Sink⟦T⟧ = interface {
        << (source:Collection⟦T⟧) → Collection⟦T⟧
    }

    type CollectionFactory⟦T⟧ = Object & interface {
        empty → Collection⟦T⟧                  // an empty collection
        with(element:T) → Collection⟦T⟧        // a collection containing a single element
        withAll(source:Collection⟦T⟧) → Collection⟦T⟧  // a collection containing the elements of source
        << (source:Collection⟦T⟧) → Collection⟦T⟧  // a collection containing the elements of source
    }

    type Iterator⟦T⟧ = interface {
        hasNext → Boolean
        next → T
    }

    type Enumerable⟦T⟧ = Collection⟦T⟧ & interface {
        values → Collection⟦T⟧
        keysAndValuesDo(action:Function2⟦Number,T,Object⟧) → Done
        sortedBy(comparison:Function2⟦T,T,Number⟧) → SelfType
        sorted → SelfType
    }

    type Sequenceable⟦T⟧ = Enumerable⟦T⟧ & interface {
        size → Number
        at(n:Number) → T
        at⟦W⟧(n:Number) ifAbsent(action:Function0⟦W⟧) → T | W
        indices → Sequence⟦Number⟧
        keys → Sequence⟦Number⟧
        second → T
        third → T
        fourth → T
        fifth → T
        last → T
        indexOf⟦W⟧(elem:T) ifAbsent(action:Function0⟦W⟧) → Number | W
        indexOf(elem:T) → Number
        reversed → Sequence⟦T⟧
    }

    type Sequence⟦T⟧ = EqualityObject & Sequenceable⟦T⟧

    type SelfType = Unknown     // becuase Self is not yet in the language
}