function combinator() {
    return C.letters()
        .then(C.char(' '))
        .then(C.lowerCase().rep())
        .then(C.char(' '))
        .then(C.notString('romane').rep())
        .then(F.eos());
}

function blank(){
    return C.char(' ').rep().thenReturns(' ');
}

function optAlternative() {
    return C.string('xyz').opt()
}

function emptyTry() {
    return F.try(C.string('xyz'));
}

const separator = () => C.string('---');

import {Streams, F, C, N} from '@masala/parser'
import {assertEquals, assertFalse, assertTrue} from '../../assert';


let response = C.char('a').rep().parse(Streams.ofString('aaaa'));
assertEquals(response.value.join(''), 'aaaa' );
assertEquals(response.offset, 4 )
assertTrue(response.isAccepted());
assertTrue(response.isConsumed());

// Partially accepted
response = C.char('a').rep().parse(Streams.ofString('aabb'));
assertEquals(response.value.join(''), 'aa' );
assertEquals(response.offset, 2 )
assertTrue(response.isAccepted());
assertFalse(response.isConsumed());

function anyOperation() {
    return C.string('*').thenReturns(MULT)
        .or(C.string('+').thenReturns(PLUS));
}

function day() {
    return C.stringIn(['MONDAY', 'TUESDAY', 'WEDNESDAY', 'THURSDAY', 'FRIDAY', 'SATURDAY', 'SUNDAY']);
}

import {assertEquals, assertTrue} from '../../assert';
import {Streams, F, C, N} from '@masala/parser'





let stream= Streams.ofString('|4.6|');
const floorCombinator = C.char('|').drop()
    .then(N.numberLiteral())    // we have ['|',4.6], we keep 4.6
    .then(C.char('|').drop())   // we have [4.6, '|'], we keep 4.6
    .map(x =>Math.floor(x));

// Parsec needs a stream of characters
let parsing = floorCombinator.parse(stream);
assertEquals( 4, parsing.value, 'Floor parsing');

/**
 * There is recursion, and we call A with lazy. We send PARAMETERS to A
 * within an array
 */
function B(aVal) {
    return C.char('B').map(bVal=> aVal.join('')+'-'+bVal).or(F.lazy(A, ['a']));
}