tricu

An interpreted language for exploring Tree Calculus
Log | Files | Refs | README | LICENSE

consumer_split_lines.tri (2140B)

      1 -- LF splitting uses reusable reverse/fold/prepend, never an eager snoc.
      2 !import "consumers.base-source" B
      3 !import "consumers.structural" S
      4 !import "consumers.lexical-worker" L
      5 !import "prelude" !Local
      6 !import "io" !Local
      7 
      8 load name = do onOk_
      9   text <- readFile (append "lib/consumer/" (append name ".scp"))
     10   pure (matchResult (_ _ : err "source parse failure" t)
     11     (named _ : ok (snd named) t) (B.compileBaseSource text))
     12 worker program initial = S.makeConsumer initial (snd program)
     13 checks splitter reverser folder prepender =
     14   let refPrepend = worker prepender t in
     15   let lexPrepend = resultOr t (L.lCompile refPrepend) in
     16   let refFold = worker folder t in
     17   let lexFold = resultOr t (L.lCompile refFold) in
     18   let refReverse = worker reverser (pair refFold refPrepend) in
     19   let lexReverse = resultOr t (L.lCompile
     20     (worker reverser (pair lexFold lexPrepend))) in
     21   let refSplit = worker splitter (pair [] refReverse) in
     22   let lexSplit = resultOr t (L.lCompile
     23     (worker splitter (pair [] lexReverse))) in
     24   let same source expected = (and?
     25     (equal? (S.runConsumer refSplit source) (ok expected t))
     26     (equal? (L.lRunChecked lexSplit source) (ok expected t))) in
     27   foldl and? true [
     28     (resultIsOk (L.lCompile refPrepend))
     29     (resultIsOk (L.lCompile refFold))
     30     (resultIsOk (L.lCompile (worker reverser (pair lexFold lexPrepend))))
     31     (resultIsOk (L.lCompile (worker splitter (pair [] lexReverse))))
     32     (same "" [])
     33     (same "a" ["a"])
     34     (same "\n" [""])
     35     (same "a\n" ["a"])
     36     (same "a\n\n" ["a" ""])
     37     (same "a\nb" ["a" "b"])
     38     (same "\r\n" ["\r"])
     39     (same "a\r\nb\n" ["a\r" "b"])
     40     (equal? (S.runConsumer refSplit (t t))
     41       (err "no matching consumer rule" t))
     42     (equal? (L.lRunChecked lexSplit (t t))
     43       (err "no matching consumer rule" t))]
     44 stage = do onOk_
     45   splitter <- load "text/splitLines"
     46   reverser <- load "reverse"
     47   folder <- load "fold"
     48   prepender <- load "prepend"
     49   pure (ok (checks splitter reverser folder prepender) t)
     50 main = io (onResult_ stage
     51   (_ : putStrLn "split-lines-load-fail")
     52   (passed : putStrLn (matchBool "split-lines-ok" "split-lines-DIFFER" passed)))
     53 main