# Is INTEGER! in PARSE Too Obfuscating?

**URL:** <https://revolt.metaeducation.com/forum/t/is-integer-in-parse-too-obfuscating/1578>\
**Category:** Parsing\
**Created:** [March 28, 2021, 5:29pm UTC](https://revolt.metaeducation.com/forum/t/is-integer-in-parse-too-obfuscating/1578 "2021-03-28T17:29:10Z")\
**Posts on this page:** 1\
**Showing post:** 9

<div class="post-metadata">

**Author:** ![hostilefork](https://revolt.metaeducation.com/forum/user_avatar/revolt.metaeducation.com/hostilefork/32/421_2.png) [@hostilefork](https://revolt.metaeducation.com/forum/u/hostilefork)\
**Post date:** [July 11, 2022, 5:11pm UTC](https://revolt.metaeducation.com/forum/t/is-integer-in-parse-too-obfuscating/1578/9 "2022-07-11T17:11:34Z")

</div>

> [@hostilefork](#):
>
> But perhaps within PARSE, literal integers could be exempted...assumed to never match integers, but be passed as a parameter.

Maybe it's just my use cases. But I don't really find myself having literal numbers of times to run a rule very often.

I almost never use something like:

```
parse data [... 5 rule ...]

```

The very few times such things come up, I think it would be clearer as:

```
parse data [... repeat 5 rule ...]

```

If integers in PARSE were literal, that would make it easier to pass them to functions like, say, SKIP.

```
parse data [... skip 3 ...]
parse data [... skip -1 ...]

```

Since I prefer NEXT as a variable name to an operation (and want people to use [NEXT OF instead of NEXT](https://revolt.metaeducation.com/forum/t/de-verbification-noun-of-x-vs-noun-x/1368) on series), I'm probably not going to push for NEXT as an arity-0 parse keyword. But **skip 1** is a bit smoother to type than **`<any>`** and is literate/generic, opening the doors to other skips.

(I like **`skip 3`** better than **`3 <any>`** for what is intended.)

## I've Demonstrated You _can_ Define INTEGER! As Repeat Count

The existence of the INTEGER! combinator shows you can do it if you want to. And Redbol PARSE wants to.

But is it really worth it...compared to keeping our beloved mathematical abstraction of the INTEGER! abstract, to be passed to any combinator to interpret?

PARSE is getting more power, with the ability to define off-the-cuff combinators and use them inline in a single parse call. So that's quite a lot of combinators that could generically interpret integers. REPEAT feels like a drop in the bucket of things you might want to do.

So I say make INTEGER! a combinator that doesn't move the parse position and just evaluates to the integer. How about that?

---

_[View the full topic](https://revolt.metaeducation.com/forum/t/is-integer-in-parse-too-obfuscating/1578)._
