gavinking

shared String formatFloat(
        "The floating point value to format."
        Float float,
        "The minimum number of allowed decimal places.
         
         If `minDecimalPlaces<=0`, the result may have no
         decimal point."
        Integer minDecimalPlaces=1,
        "The maximum number of allowed decimal places.
         

gavinking

shared void run() {
    for (perm in permutations("ABCD").indexed) {
        print(perm);
    }
}

shared {Element[]*} permutations<Element>
            (List<Element> list) 
        => object satisfies {Element[]*} {
    

gavinking

shared void balancedBrackets() {
    value nextRandom = random();
    for (length in 1..10) {
        value text = generate(nextRandom, length);
        print("``text.padTrailing(20)`` - ``if (balanced(text)) then "OK" else "NOT OK"``");
    }
}

Boolean balanced(String input)
        => !input

gavinking

"Parse a properties file."
void parsePropertiesFile(String textContent, 
        void handleEntry(String key, String text)) {
    value lines = textContent.lines.iterator();
    while (!is Finished rawline = lines.next()) {
        value builder = StringBuilder();
        builder.append(rawline);
        variable value lastline = rawline;
        while (lastline.endsWith("\\"), //line continuation
                !is Finished nextline = lines.next()) {

gavinking

import ceylon.locale {
    systemLocale
}
import ceylon.time {
    today,
    date
}
import ceylon.time.base {
    monthOf
}

gavinking

"Finds the (last) longest substring that contains
 at most two unique characters"
String longest2UniqueCharSubstring(String s)
        => let (init = [[0, 0, 0, 0], 0, '\0', '\0'],
                mpos = s.fold(init)((acc,ch)
                     => let ([[mb,me,cb,ce],cb1,ch0,ch1] = acc,
                             ce1 = ce+1,
                             max = (Integer b, Integer e) 
                                 => me-mb > e-b then [mb,me,b,e] 
                                                else [b,e,b,e])

gavinking

import ceylon.language.serialization {
    serialization,
    Deconstructor
}
import ceylon.language.meta.model {
    ClassModel,
    Type
}
import ceylon.language.meta.declaration {
    ValueDeclaration,

gavinking

"A generic function that produces a memoized version
 of the given [[function|fun]]. Works for any function 
 arity."
Callable<Return,Args> memoize<Return,Args>(Callable<Return,Args> fun) 
        given Args satisfies Anything[] {
    value cache = HashMap<Args,Return&Object|Finished>();
    function callFun(Args args) {
        //we'll use finished as a convenient
        //unit value to represent the case
        //that the function returned null

gavinking

import ceylon.collection {
    LinkedList
}
import ceylon.math.float {
    sin,
    pi
}


"Map a function of arity `n` to a stream of values. In each

gavinking

"Encoding of natural numbers at 
 type level."
interface Nat of Zero|Succ<Nat> {}
"The natural number `0`."
interface Zero satisfies Nat {}
"The natural number `N+1` for a
 given natural number `N`."
interface Succ<N>
        satisfies Nat
        given N satisfies Nat {}