feat(v2): End on renaming Streams.ofString to eventually Stream.ofChars

Author: nicolas-zozol

README.md

@@ -70,7 +70,7 @@ const combinator = helloParser.then(white.rep()).then(worldParser)
 
 ```js
 // N: Number Bundle, C: Chars Bundle
-import { Streams, N, C } from '@masala/parser'
+import { Stream, N, C } from '@masala/parser'
 
 const stream = Stream.ofChars('|4.6|')
 const floorCombinator = C.char('|')
@@ -124,14 +124,14 @@ that represents your problem. After parsing, there are two subtypes of
 - `Reject` if it could not.
 
 ```js
-let response = C.char('a').rep().parse(Streams.ofChars('aaaa'))
+let response = C.char('a').rep().parse(Stream.ofChars('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.ofChars('aabb'))
+response = C.char('a').rep().parse(Stream.ofChars('aabb'))
 assertEquals(response.value.join(''), 'aa')
 assertEquals(response.offset, 2)
 assertTrue(response.isAccepted())
@@ -163,7 +163,7 @@ The goal is to check that we have Hello 'someone', then to grab that name
 
 ```js
 // Plain old javascript
-import { Streams, C } from '@masala/parser'
+import { Stream, C } from '@masala/parser'
 
 var helloParser = C.string('Hello')
     .then(C.char(' ').rep())
@@ -182,7 +182,7 @@ And each new Parser is a combination of Parsers given by the standard bundles or
 previous functions.
 
 ```js
-import { Streams, N, C, F } from '@masala/parser'
+import { Stream, N, C, F } from '@masala/parser'
 
 const blanks = () => C.char(' ').optrep()
 
@@ -220,7 +220,7 @@ function combinator() {
 }
 
 function parseOperation(line) {
-    return combinator().parse(Streams.ofChars(line))
+    return combinator().parse(Stream.ofChars(line))
 }
 
 assertEquals(4, parseOperation('2   +2').value, 'sum: ')

documentation/chars-bundle.md

@@ -5,9 +5,9 @@
 Using Only Chars
 
 ```js
-import { Streams, F, C } from '@masala/parser'
+import { Stream, F, C } from '@masala/parser'
 
-let stream = Streams.ofChars('abc')
+let stream = Stream.ofChars('abc')
 const charsParser = C.char('a')
     .then(C.char('b'))
     .then(C.char('c'))
@@ -20,7 +20,7 @@ assertArrayEquals(['a', 'b', 'c'], parsing.value)
 Or just using `C.letter` and `rep()`:
 
 ```js
-stream = Streams.ofChars('Hello World')
+stream = Stream.ofChars('Hello World')
 const letterParser = C.letter
     .rep() // 'Hello'
     .then(C.char(' ')) // space is not a letter
@@ -36,7 +36,7 @@ We can improve our control by using the right function at the right time. Here,
 Using `C.letters` and `C.string`
 
 ```js
-stream = Streams.ofChars('Hello World')
+stream = Stream.ofChars('Hello World')
 const helloParser = C.string('Hello').then(C.char(' ')).then(C.letters)
 
 parsing = helloParser.parse(stream)
@@ -48,22 +48,22 @@ assertArrayEquals(['Hello', ' ', 'World'], parsing.value)
 ### `letterAs(symbol)`:
 
 ```js
-import { Streams, F, C } from 'masala-parser'
+import { Stream, F, C } from 'masala-parser'
 
-assertTrue(C.letterAs().parse(Streams.ofChars('a')).isAccepted())
+assertTrue(C.letterAs().parse(Stream.ofChars('a')).isAccepted())
 assertTrue(
-    C.letterAs(C.OCCIDENTAL_LETTER).parse(Streams.ofChars('a')).isAccepted(),
+    C.letterAs(C.OCCIDENTAL_LETTER).parse(Stream.ofChars('a')).isAccepted(),
 )
-assertTrue(C.letterAs(C.UTF8_LETTER).parse(Streams.ofChars('Б')).isAccepted())
+assertTrue(C.letterAs(C.UTF8_LETTER).parse(Stream.ofChars('Б')).isAccepted())
 assertTrue(
-    !C.letterAs(C.OCCIDENTAL_LETTER).parse(Streams.ofChars('÷')).isAccepted(),
+    !C.letterAs(C.OCCIDENTAL_LETTER).parse(Stream.ofChars('÷')).isAccepted(),
 )
 ```
 
 ### stringIn
 
 ```js
-stream = Streams.ofChars('James')
+stream = Stream.ofChars('James')
 const combinator = C.stringIn(['The', 'James', 'Bond', 'series'])
 parsing = combinator.parse(stream)
 assertEquals('James', parsing.value)
@@ -77,7 +77,7 @@ parser. The argument can be either a raw range string `a-zA-Z_` or a RegExp
 consumes exactly one code unit.
 
 ```js
-let stream = Streams.ofChars('myUser')
+let stream = Stream.ofChars('myUser')
 
 //identifier parser-> myUser: ok ; 0myUser: not ok
 const firstChar = C.inRegexRange('a-zA-Z_')

documentation/flow-bundle.md

@@ -87,7 +87,7 @@ in a document. `F.dropTo(string|parser)` will do the same, but dropping the
 content.
 
 ```js
-const line = Streams.ofChars('I write until James Bond appears')
+const line = Stream.ofChars('I write until James Bond appears')
 
 const combinator = F.moveUntil(C.string('James'))
     .then(F.dropTo('appears'))

documentation/numbers-bundle.md

@@ -3,7 +3,7 @@
 **Import**
 
 ```ts
-import { N, Streams } from '@masala/parser'
+import { N, Stream } from '@masala/parser'
 ```
 
 ## Number parser
@@ -24,9 +24,9 @@ The parsing is returned as a JavaScript type `number`.
 **Examples**
 
 ```ts
-N.number().parse(Streams.ofChars('42')) // → 42
-N.number().parse(Streams.ofChars('-12.5')) // → -12.5
-N.number().parse(Streams.ofChars('3.1e-2')) // → 0.031
+N.number().parse(Stream.ofChars('42')) // → 42
+N.number().parse(Stream.ofChars('-12.5')) // → -12.5
+N.number().parse(Stream.ofChars('3.1e-2')) // → 0.031
 ```
 
 Grammar: `[+-]? (digits ("." digits?)? | "." digits) ([eE][+-]?digits)?`
@@ -46,6 +46,6 @@ const ratio = N.number().then(C.char('/')).then(N.number())
 **Examples**
 
 ```ts
-N.digit().parse(Streams.ofChars('7')) // '7'
-N.digits().parse(Streams.ofChars('1234')) // '1234'
+N.digit().parse(Stream.ofChars('7')) // '7'
+N.digits().parse(Stream.ofChars('1234')) // '1234'
 ```

documentation/parser-core-functions.md

@@ -45,7 +45,7 @@ Here is an example of a home-made parser for going back after an Accept:
 - Construct a Tuple of values from previous accepted values
 
 ```js
-let stream = Streams.ofChars('abc')
+let stream = Stream.ofChars('abc')
 const charsParser = C.char('a')
     .then(C.char('b'))
     .then(C.char('c'))
@@ -59,7 +59,7 @@ assertEquals(parsing.value, 'abc')
 - Uses `then()` and returns only the left or right value
 
 ```js
-const stream = Streams.ofChars('|4.6|')
+const stream = Stream.ofChars('|4.6|')
 const floorCombinator = C.char('|')
     .drop()
     .then(N.number()) // we have ['|',4.6], we keep 4.6
@@ -78,7 +78,7 @@ assertEquals(4, parsing.value, 'Floor parsing')
 - Change the value of the response
 
 ```js
-const stream = Streams.ofChars('5x8')
+const stream = Stream.ofChars('5x8')
 const combinator = N.integer()
     .then(C.charIn('x*').drop())
     .then(N.integer())
@@ -93,7 +93,7 @@ assertEquals(combinator.val(stream), 40)
 - It's a simplification of map
 
 ```js
-const stream = Streams.ofChars('ab')
+const stream = Stream.ofChars('ab')
 // given 'ac', value should be ['X' , 'c']
 const combinator = C.char('a').returns('X').then(C.char('b'))
 assertEquals(combinator.val(stream).array(), ['X', 'b'])
@@ -142,7 +142,7 @@ C.char('a').opt(C.char('b')).char('c')
 - Ensure a parser is repeated **at least** one time
 
 ```js
-const stream = Streams.ofChars('aaa')
+const stream = Stream.ofChars('aaa')
 const parsing = C.char('a').rep().parse(stream)
 test.ok(parsing.isAccepted())
 // We need to call list.array()
@@ -187,7 +187,7 @@ while testing or().
 const eater = C.char('a').then(C.char('a'))
 const parser = eater.or(C.char('b'))
 
-const stream = Streams.ofChars('ab')
+const stream = Stream.ofChars('ab')
 const parsing = parser.parse(stream)
 expect(parsing.isAccepted()).toBe(false)
 expect(parsing.offset).toBe(1) // ✨ this is the point ! one 'a' is consumed
@@ -272,16 +272,16 @@ It can help you to read your document knowing what happen previously
 
         'expect (filter) to be accepted': function(test) {
         test.equal(parser.char("a").filter(a => a === 'a')
-        .parse(Streams.ofChars("a")).isAccepted(), true, 'should be accepted.');
+        .parse(Stream.ofChars("a")).isAccepted(), true, 'should be accepted.');
         }
 
 ### match (matchValue)
 
 - Simplification of `filter()`
 - Check if the stream value is equal to the _matchValue_
 
-                            //given 123
-                            N.number().match(123)
+                              //given 123
+                              N.number().match(123)
 
 ### error()
 

documentation/recursion.md

@@ -7,7 +7,7 @@ parsing
 
 ## Recursion fail
 
-        const {Streams, F, N, C, X} = require('@masala/parser');
+        const {Stream, F, N, C, X} = require('@masala/parser');
 
         function A(){
             return C.char('A').then(B());
@@ -20,7 +20,7 @@ parsing
         console.log('=== Building Parser ====');
         const parser = A();
         console.log('=== NEVER THERE ====');
-        let parsing = parser.parse(Streams.ofChars('AAAAAB'));
+        let parsing = parser.parse(Stream.ofChars('AAAAAB'));
 
 ## Lazy Recursion
 
@@ -39,8 +39,7 @@ parsing the stream.
         console.log('=== Building Parser ====');
         const parser = A();
         console.log('=== GETTING THERE ====');
-        let parsing = parser.parse(Streams.ofChars('AAAAAB')); // Accepted :)
-
+        let parsing = parser.parse(Stream.ofChars('AAAAAB')); // Accepted :)
 
 ## Operations
 

documentation/troubleshooting.md

@@ -12,6 +12,6 @@ const floorCombinator = C.string('Hello')
     .then(C.string('fail'))
     .debug('wont be displayed', true)
 
-const parsing = floorCombinator.parse(Streams.ofChars('Hello World !!!'))
+const parsing = floorCombinator.parse(Stream.ofChars('Hello World !!!'))
 assertFalse(parsing.isAccepted(), 'Testing debug')
 ```

faq.md

@@ -1,10 +1,12 @@
-Difference between Parser.then() and Parser.thenRight()
+# FAQ
+
+## Difference between Parser.then() and Parser.thenRight()
 
 ```js
 p1.thenRight(p2) === p1.drop().then(p2)
 ```
 
-Difference between Parser.then() and Parser.thenLeft()
+## Difference between Parser.then() and Parser.thenLeft()
 
 ```js
 p1.thenLeft(p2) === p1.then(p2.drop())

integration-ts/examples/1-easy/chars.spec.ts

@@ -1,12 +1,12 @@
 import { describe, it, expect } from 'vitest'
-import { Streams, F, C } from '@masala/parser'
+import { Stream, F, C } from '@masala/parser'
 
 /**
  * Created by Nicolas Zozol on 05/11/2017.
  */
 describe('Character parsers', () => {
     it('should parse sequential characters followed by EOS', () => {
-        const stream = Streams.ofChars('abc')
+        const stream = Stream.ofChars('abc')
         const charsParser = C.char('a')
             .then(C.char('b'))
             .then(C.char('c'))

integration-ts/examples/1-easy/floor.spec.ts

@@ -1,9 +1,9 @@
 import { describe, it, expect } from 'vitest'
-import { Streams, C, N } from '@masala/parser'
+import { Stream, C, N } from '@masala/parser'
 
 describe('Floor combinator', () => {
     it('should parse a number between pipes and floor it', () => {
-        let stream = Streams.ofChars('|4.6|')
+        let stream = Stream.ofChars('|4.6|')
         const floorCombinator = C.char('|')
             .drop()
             .then(N.number()) // we have ['|',4.6], we keep 4.6