# This is line 1 of a certain type of block.
  The block continues here because of the indentation.

* This could be a list item

  p With a paragraph in it
    that continues on multiple lines...and
    has a strange #(inline something or other
    delimited by hash-parens)#...

  ~~~{:foo "bar", :baz 123} tags can also have
    attributes parsed as EDN...

* here is the next list item

# This is all
  part of the
    same block
  and the next
  block
    doesnt
      start until the
  an "outdent" is seen

This is an outdent, so
the above block will 
have been ended.

# This is not
  all part of the same
  # block because this
    tag creates a nested
    block

(my-parser text) => ([:block "This is not" "all part of the same" "# block because this" "   tag ..."])
(insta/transform *1 {:block (fn [& strs] (my-parser (str/join "\n" strs)))})

# My Title

<h1>My Title</h1>

<h1>My Title <small>The Best Thing Ever</small></h1>

# My Title <<The Best Thing Ever>>

(def minimum-one-not-zero
  (insta/parser
    "EXP = N | S;
    S = (ZN '+')* N ('+' ZN)*;
    N =  '1' | '2' | '3' | '4' | '5' | '6' | '7' | '8' | '9';
    ZN = '0' | N;"))

Parse error at line 1, column 4:
0+0
   ^
Expected:
"+"

S = &(#".*[1-9]") (N | (N ('+' N)+);

S = N ('+' N)* | (N '+')* '0' ('+' ZN)*;

REGEXP = <'/'> #'(?:.(?!(?<![\\\\])/))+.?' <'/'>

(let [s "abcd"
               g "Q='a' 'b'"
               p (i/parser g)
               t (p s :partial true)]
               (apply subs
                             (into [s] (i/span t))))

boot.user=> (def p (insta/parser "
<S> = ows (exponent ows)+
<exponent> = token <'^'> super
super = token | <'{'> token <'}'>
<token> = #'[^\\s\\^{}]+'
<ows> = <#'\\s*'>
"))
#'boot.user/p
boot.user=> (p "foo^2 x^{x+1}")
("foo" [:super "2"] "x" [:super "x+1"])

"sentence = define / explain / help / catchall
<<skipped definitions>>
 catchall = #'(.|[\n\r])*'"

(def p (insta/parser ...))
(let [result (p input-string)
      transformed (insta/transform p {...})]
  (when-not (insta/failure? transformed)
    transformed))

<string> = '\\\\*' | #'[^*/_+=~^_\\\\]+'

user> (inline-markup "a\\* b")
("a" "\\*" " b")

aaaa
bbb
cccccc

S = A '\n' B '\n' C
A = 'a'+
B = 'b'+
C = 'c'+

S = #'a+\n' #'b+\n' #'c+'

S = A ows B ows C
A = 'a'+
B = 'b'+
C = 'c'+
(* optional whitespace *)
<ows> = <#'\s*'>

S = #'shown-part(?=hidden-part)' <#'hidden-part'>

organum.core> (headlines content)
[:S [:token [:content "This is an attempt...

organum.core> (re-find #"a" "a")
"a"
organum.core> (re-find #"(?:a)" "a")
"a"

* The First : Section :foo:bar:

(def headlines
  (insta/parser
   "<S> = token (ows token)*
    <token> = section / content
    section = h (ows content)*
    h = ows stars <#'\\s+'> (todo <#'\\s+'>)? title
    <title> = (#'.'+ ws-line? tags) / #'.+'
    stars = #'^\\*+'
    todo = #'TODO|DONE'
    tags = <':'> (tag <':'>)+ ws
    <tag> = #'[

"comment = ‘/*’ .* ‘*/‘"

"comment = <'/*'> #'.*' <'*/'>"

<string> = dqoute #'([^"\\]|\\.)*' dqoute
   <dqoute> = <'\"'>

/* This is a comment */

"hello" = "Hello!";

/* This is another comment */
"click_button" = "Click";

/* Title bar, prints the number of selected products (The translation should be short due to the limit of 100 characters for the title of the mobile app) */
"bar_print_$_selected_products" = "You Selected %@ Products”;

(def all-keywords-ever (map keyword (range)))

;; each time you dynamically create a parser
(let [my-syms ...
kws (zipmap my-syms all-keywords-ever)]
...)

(def p (insta/parser "
S = A B A | B A B
<A> ('a' <'c'> 'b')+
<B> ('b' 'a')+
"))

(generate p [:S "a" "b" "b" "a" "a" "b"])
=> ("acbbaacb")

(defn enlive-output->datascript-datums [m]
 (if-not (map? m)
    {:type :value :value m}
    (as-> m $
        (assoc $ :meta (meta m))
        (assoc $ :db/id (d/tempid :mcc))
        (transform [:content ALL] enlive-output->datascript-datums $))))

never-succeed = never-succeed

user=> (re-matches #"[2-9]|[1-9][0-9]+" "25")
"25"
user=> (re-seq #"[2-9]|[1-9][0-9]+" "25")
("2" "5")
user=> (re-find #"[2-9]|[1-9][0-9]+" "25")
"2"

(def parser (insta/parser "quote \"'\" | '\"'"))

hexEscape = '\'

hexEscape = '\\'

(def input "nextSource : Source a -> Source a
nextSource (Source a next) =
    Source (next a) next


nextSource : Source a -> Source a
nextSource (Source a next) =
    Source (next a) next

nextSource : Source a -> Source a
nextSource (Source a next) =
    Source (next a) next

nextSource : Source a -> Source a
nextSource (Source a next) =
    Source (next a) next

nextSource : Source a -> Source a
nextSource (Source a next) =
    Source (next a) next

nextSource : Source a -> Source a
nextSource (Source a next) =
    Source (next a) next

nextSource : Source a -> Source a
nextSource (Source a next) =
  Source (next a) next

nextSource : Source a -> Source a
nextSource (Source a next) =
  Source (next a) next

nextSource : Source a -> Source a
nextSource (Source a next) =
  Source (next a) next

nextSource : Source a -> Source a
nextSource (Source a next) =
  Source (next a) next

nextSource : Source a -> Source a
nextSource (Source a next) =
  Source (next a) next

")

start = (<ws>* block <ws>*)+

start = (<ws> block <ws>)+

Name = #'(?!\\b(if|then|else|in|let|case|of)\\b)[A-Z][a-zA-Z0-9]*'
    name = #'(?!\\b(if|then|else|in|let|case|of|type)\\b)[a-z][a-zA-Z0-9]*'

symbol = #'(?!(->|=)\\b)[+/*<>:&|=^?%#~!-]+'

Regex = <'/'> Alternation <'/'> MatchFlag*

Alternation = Concatenation (<'|'> Concatenation)*

Concatenation = SuffixedExpr*

SuffixedExpr = SingleExpr Suffix?
SingleExpr = BaseExpr | ParenthesizedExpr
ParenthesizedExpr = <'('> GroupFlags? Alternation <')'>
Suffix = (Optional | Positive | NonNegative | CurlyRepetition) Quantifier?
Optional = <'?'>
Positive = <'+'>
NonNegative = <'*'>
CurlyRepetition = <'{'> #"\d+" (<','> #"\d+" ?) ? <'}'>
Quantifier = '?' | '+'
BaseExpr = CharExpr | LiteralChar | Anchor | BackReference

Anchor = '^' | '$' | '\\' #"[bB]"
LiteralChar = PlainChar | EscapedChar

BackReference = <'\\'> #"[1-9][0-9]*"

PlainChar = #"[^.|\\+*$^\[(){?]"
CharExpr = Dot | LiteralChar | BCC
Dot = '.'

BCC = <'['> BCCUnionLeft? <']'>

BCCUnionLeft = BCCNegation? BCCElemBase*

BCCNegation = '^'

BCCElemBase = BCCCharNonRange | SpecialCharClass | BCCRange | BCC
BCCRangeRightable = BCCCharEndRange | SpecialCharClass
BCCRange = BCCChar <'-'> BCCCharEndRange
BCCRangeWithBracket = <']-'> BCCCharEndRange
BCCCharNonRange = BCCChar !('-' BCCRangeRightable)
BCCChar = BCCPlainChar | EscapedChar
BCCCharEndRange = BCCPlainChar | EscapedChar
BCCPlainChar = #"[^\]\[\\]" | '\\b'

EscapedChar = SpecialCharClass | NormalSlashedCharacters | ControlChar | HexChar | BasicEscapedChar

HexChar = ShortHexChar | MediumHexChar | LongHexChar | VeryLongHexChar
ShortHexChar = <'\\x'> #'[0-9a-fA-F]{2}'
MediumHexChar = <'\\u'> #'[0-9a-fA-F]{4}'
LongHexChar = <'\\x{'> #'[0-9a-fA-F]{4}' <'}'>
VeryLongHexChar = <'\\x{'> #'[0-9a-fA-F]{6}' <'}'>
BasicEscapedChar = <'\\'> #"[\s\S]"
SpecialCharClass = <'\\'> #"[dDwWsSv0]"

NormalSlashedCharacters = #"\\[tnrf]"

ControlChar = <'\\c'> #"[A-Z]"

(** FLAGS **)
GroupFlags = NonCapturingMatchFlags
           | PositiveLookAheadFlag
           | NegativeLookAheadFlag

NonCapturingMatchFlags = <'?'> !')' <':'>
PositiveLookAheadFlag = <'?='>
NegativeLookAheadFlag = <'?!'>

MatchFlag = #"[gimuy]"

Concatenation = SuffixedExpr*

SuffixedExpr = LiteralChar CurlyRepetition?

CurlyRepetition = <'{'> #"\d+" <'}'>

LiteralChar = #"."

Concatenation = SuffixedExpr*

SuffixedExpr = LiteralChar CurlyRepetition? / AnyLiteralChar

CurlyRepetition = <'{'> #"\d+" <'}'>

LiteralChar = #"[^{]"
AnyLiteralChar = #"."

Regex = <'/'> Alternation <'/'> MatchFlag*

Alternation = Concatenation (<'|'> Concatenation)*

Concatenation = SuffixedExpr*

SuffixedExpr = SingleExpr Suffix? / CurlyRepetition / LiteralSpecialChar
SingleExpr = BaseExpr | ParenthesizedExpr
ParenthesizedExpr = <'('> GroupFlags? Alternation <')'>
Suffix = (Optional | Positive | NonNegative | CurlyRepetition) Quantifier?
Optional = <'?'>
Positive = <'+'>
NonNegative = <'*'>
CurlyRepetition = <'{'> #"\d+" (<','> #"\d+" ?) ? <'}'>
Quantifier = '?' | '+'
BaseExpr = CharExpr | LiteralChar | Anchor | BackReference

Anchor = '^' | '$' | '\\' #"[bB]"
LiteralChar = PlainChar | EscapedChar
LiteralSpecialChar = '{'

BackReference = <'\\'> #"[1-9][0-9]*"

PlainChar = #"[^.|\\+*$^\[(){?]"
CharExpr = Dot / LiteralChar / BCCEmpty / BCC
Dot = '.'

BCC = <'['> BCCUnionLeft? <']'>
BCCEmpty = '[]'

BCCUnionLeft = BCCNegation? BCCElemBase*

BCCNegation = '^'

BCCElemBase = BCCCharNonRange | SpecialCharClass | BCCRange | BCC
BCCRangeRightable = BCCCharEndRange | SpecialCharClass
BCCRange = BCCChar <'-'> BCCCharEndRange
BCCRangeWithBracket = <']-'> BCCCharEndRange
BCCCharNonRange = BCCChar !('-' BCCRangeRightable)
BCCChar = BCCPlainChar | EscapedChar
BCCCharEndRange = BCCPlainChar | EscapedChar
BCCPlainChar = #"[^\]\[\\]" | '\\b'

EscapedChar = SpecialCharClass / NormalSlashedCharacters / ControlChar / HexChar / BasicEscapedChar

HexChar = ShortHexChar | MediumHexChar | LongHexChar | VeryLongHexChar
ShortHexChar = <'\\x'> #'[0-9a-fA-F]{2}'
MediumHexChar = <'\\u'> #'[0-9a-fA-F]{4}'
LongHexChar = <'\\x{'> #'[0-9a-fA-F]{4}' <'}'>
VeryLongHexChar = <'\\x{'> #'[0-9a-fA-F]{6}' <'}'>
BasicEscapedChar = <'\\'> #"[\s\S]"
SpecialCharClass = <'\\'> #"[dDwWsSv0]"

NormalSlashedCharacters = #"\\[tnrf]"

ControlChar = <'\\c'> #"[A-Z]"

(** FLAGS **)
GroupFlags = NonCapturingMatchFlags
           | PositiveLookAheadFlag
           | NegativeLookAheadFlag

NonCapturingMatchFlags = <'?'> !')' <':'>
PositiveLookAheadFlag = <'?='>
NegativeLookAheadFlag = <'?!'>

MatchFlag = #"[gimuy]"

(def parser
  (insta/parser "regra = <'filtro'> <ws> elemento+
                elemento = operador <ws> operando
                operador = ('origem')
                operando = #'[a-zA-Z0-9\\-]([0-9a-zA-Z\\-]*)'
                ws = #'\\s+'"))
(parser "filtro 
        origem 001-ARTICO 
        origem 011-BALDACCI")

WrappedLabel = UnderscorePair Word UnderscorePair
UnderscorePair = "__"
Word = #".+(?=__)" (* a valid word is hereby contrained to anything that does not include an UnderScorePair *)

(def tp (insta/parser "
s = expression
<expression> = binop / integer
integer = #'[0-9]+'
<binop> = times / plus
times = expression <'*'> expression
plus = expression <'+'> expression"
                      :auto-whitespace whitespace))

parser> (tp "5 + 3 * 7")
[:s [:times [:plus [:integer "5"] [:integer "3"]] [:integer "7"]]]

expr = add-sub
add-sub = mul-div (('+' | '-') mul-div)*
mul-div = term (('*' | '/') term)*
term = number | <'('> add-sub <')'>

{:tag :regexp,
 :expecting #"^[0-9]+\.?[0-9]*"}

{:tag :regexp,
 :expecting #"^\/^[0-9]+\.?[0-9]*\/"}

;; Regexp terminals are handled differently in cljs
 ;; (= :regexp (:tag form))
 ;; `(merge (c/regexp ~(str (:regexp form)))
 ;;         ~(dissoc form :tag :regexp))

(insta/defparser ex7
  "
  doc = (text | tag)*
  text = #'[^@]*'
  tag = '@' #'[a-z]*' inner-text*
  inner-text = '{' #'[^}]*' '}'
  ")

(ex7 "some text @toto{inner text}")

[:doc [:text "some text "] [:tag "@" "toto"] [:text "{inner text}"]]

[:doc [:text "some text "] [:tag "@" "toto" [:inner-text "{" "inner text" "}"]]]

(def my-p 
  (instaparse.core/parser 
    "spec = (field-spec <' '?>)+
     field-spec = <'['>name ' '* <':'> ' '* (width | not-inclusive | not-exclusive | rest)<']'>
     name = #'[^:]+'
     width = <'{'> #'\\d+' <'}'>
     not-inclusive = <'\\\\'> #'.'
     not-exclusive = <'/'> #'.'
     rest = '*'    
    "))

(def parse2
  (insta/parser
   "<INPUT>       = (INSTRUCTION <','>)+ INSTRUCTION 
    <INSTRUCTION> = SPIN | EXCHANGE | PARTNER
    SPIN          = <'s'> POSITION
    EXCHANGE      = <'x'> POSITION <'/'> POSITION
    PARTNER       = <'p'> PROGRAM  <'/'> PROGRAM
    <POSITION>    = #'\\d\\d?'
    <PROGRAM>     = #'[a-p]'"))

(defn make-layout-parser-internal []
  (insta/parser
    "layout-string = col-delim (col-align col-delim)+
     col-delim    = (col-fill | col-padding)*
     col-fill     = ('F' | 'f')
     col-padding  = #'[^\\[\\]fF]*'
     col-align    = <'['> ('L' | 'l' | 'C' | 'c' | 'R' | 'r') <']'>"))

(insta/parser
    "layout   = (align | delim | repeat)+
     repeat   = <'{'> (align | delim)+ <'}'>
     delim    = (fill | padding)+
     fill     = 'F'
     padding  = #'[^\\[\\]{}fF]*'
     align    = <'['> ('L' | 'C' | 'R' | 'V') <']'>"
    :string-ci true))

layout = delim? ((align | repeat) delim?)*
repeat = <'{'> delim? (align delim?)* <'}'>

delim = (fill | padding)+ !delim

type = 'int' | 'boolean' | className

className = identifier

identifier = #"[A-Za-z_]+[A-Za-z0-9_]*"

(insta/parse
  (insta/parser "s = #'\\\\'")
  "\\\\")
=> Parse error at line 1, column 1:
\\
^
Expected:
#"\\" (followed by end-of-string)

(insta/parse
  (insta/parser "s = #\"\\\\\"")
  "\\\\")
=> Parse error at line 1, column 1:
\\
^
Expected:
#"\\" (followed by end-of-string)

(insta/parse
  (insta/parser "s = #'\\\\\\\\'")
  "\\\\")

title __Simple__ communication example\non several lines
Alice -> Bob: Authentication Request

def f(x):
  if x == 1:
    return 2;
  else:
    return 3;

def f(x):
→if x == 1:
→return 2;
←else:
→return 3;
←←

[:def "f(x)"
 [:nested-block
  "if x == 1:"
  "  return 2;"
  "else:"
  "  return 3;"]]

S = def | if | ...
def = <'def '> thing-you're-deffing <':\n'> nested-block
nested-block = (' ' #".*\n?")*

=> (->> (arithmetic "1-2/(3-4)+5*6")
     (insta/transform
       {:add +, :sub -, :mul *, :div /,
        :number clojure.edn/read-string :expr identity}))
33

(defn- hiccup-transform
  [transform-map parse-tree]
  (if (not (empty? parse-tree))
    (let [transform (transform-map (first parse-tree))]
      (apply transform (map (partial hiccup-transform transform-map)
                            (next parse-tree))))
    parse-tree))

(->>
   ((insta/parser
     "VALOR = CODIGO BARRAS
CODIGO = 2DIGIT
BARRAS = 3DIGIT
" :input-format :abnf) "12334")
   (insta/transform {:DIGIT (comp str)}))

((insta/parser
     "VALOR = CODIGO BARRAS
CODIGO = #'.{3}'
BARRAS = #'.{2}'
") "12334")

S = 'a' | S 'a'

(def p 
  (insta/parser
    "<S> = (block | TXT)*
     block = <'{{'> TXT <'}}'>
     <TXT> = (OPEN | CLOSE | A | block)*
     <OPEN> = !'{' '{'
     <CLOSE> = !'}' '}'
     <A> = #'[^{}]*'"))

=> Parse error at line 1, column 2:
x{a}
 ^
Expected one of:
"{{"
"}"
NOT "{"

<OPEN> = '{' !'{'
<CLOSE> = '}' !'}'

<S> = TXT*
block = <'{{'> TXT <'}}'>
<TXT> = (block / A)*
<A> = #'[^{}]*' | '{' | '}'

<condition_block> = "Condition" : { <condition_map> }

condition_block = "Condition" ":" "{" condition_map "}"

user=> (def s
   #_=>   "NAME=Thing 1
   #_=> ACTIVE=120201-171231
   #_=>
   #_=> NAME=Thing 2
   #_=> ACTIVE=120201-171231")
   #_=>
#'user/s

user=> (def grammar
   #_=>   (insta/parser
   #_=>     "top = (block <newline?>)+
   #_=>      block = line+ !line
   #_=>      line = key <'='> value <newline?>
   #_=>      key = #'[A-Z]+'
   #_=>      value = #'[^\n]*'
   #_=>      newline = '\n'"))
   #_=>
#'user/grammar

user=> (clojure.pprint/pprint (insta/parse grammar s))
[:top
 [:block
  [:line [:key "NAME"] [:value "Thing 1"]]
  [:line [:key "ACTIVE"] [:value "120201-171231"]]]
 [:block
  [:line [:key "NAME"] [:value "Thing 2"]]
  [:line [:key "ACTIVE"] [:value "120201-171231"]]]]
nil

S = line (separator line)*
separator = '\n' | '\r'

((insta/parser
   "Paragraph = NonBlankLine+ BlankLine+
    BlankLine = #'[ \\t]'* EOL
    NonBlankLine = #'\\S'+ EOL
    EOL = (#'\\n' | EOF)
    EOF = #'\\Z'")
 "abc\ndef\n")

=> 
[:Paragraph
 [:NonBlankLine "a" "b" "c" [:EOL "\n"]]
 [:NonBlankLine "d" "e" "f" [:EOL [:EOF ""]]]
 [:BlankLine [:EOL "\n"]]]

((insta/parser
   "Paragraph = NonBlankLine+ BlankLine+
    BlankLine = #'[ \\t]'* EOL
    NonBlankLine = #'\\S'+ EOL
    EOL = (#'\\n' | EOF)
    EOF = !#'.'")
 "abc\ndef\n")
=>
[:Paragraph [:NonBlankLine "a" "b" "c" [:EOL "\n"]]
            [:NonBlankLine "d" "e" "f" [:EOL "\n"]]]

((insta/parser
   "Paragraph = NonBlankLine+ BlankLine+
    BlankLine = #'[ \\t]'* EOL
    NonBlankLine = #'\\S'+ EOL
    EOL = (#'\\n' | EOF)
    EOF = 'EOF' #'\\Z'") ; works as well with !#'.'
 "abc\ndef\nEOF")
=>
[:Paragraph
 [:NonBlankLine "a" "b" "c" [:EOL "\n"]]
 [:NonBlankLine "d" "e" "f" [:EOL "\n"]]
 [:BlankLine [:EOL [:EOF "EOF" ""]]]]

X := Y* Z*

Y := CHAR
Z := CHAR

CHAR := ('a' | 'b' | 'c')

X := Y* !Y Z*

remainder_sort_names := '' | ',' sort_name remainder_sorts