# Shim Code for Modal Arguments

**URL:** <https://revolt.metaeducation.com/forum/t/shim-code-for-modal-arguments/1185>\
**Category:** Show & Tell\
**Created:** [July 23, 2019, 1:08am UTC](https://revolt.metaeducation.com/forum/t/shim-code-for-modal-arguments/1185 "2019-07-23T01:08:31Z")\
**Posts on this page:** 2\
**Page:** 1

<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 23, 2019, 1:08am UTC](https://revolt.metaeducation.com/forum/t/shim-code-for-modal-arguments/1185/1 "2019-07-23T01:08:31Z")

</div>

> **UPDATE** : _MODAL PARAMETERS ARE NOW DEAD!_ ...as far as the core is concerned. It was troubling code that contaminated the model, and it will be troubling no longer.
> 
> The [elegant solution of isotopic blocks](https://revolt.metaeducation.com/forum/t/a-justification-of-generalized-isotopes/1918) is now solving what they were trying to do.
> 
> Regardless, modal parameters were based on an interesting idea: to use literal pattern recognition at the callsite to control turning refinements on and off.

* * *

**Modal Parameters** are an idea to mark an argument conveniently as controlling a refinement--without mentioning that refinement at the callsite, or needing a specialization of the function dispatched through a different name.

Perhaps it's easiest to see by example:

```
 demo: function [@a /mode-a @b /mode-b] [
     print ["a:" mold a]
     print ["mode-a:" mold mode-a else ["; null"]]
     print ["b:" mold b]
     print ["mode-b:" mold mode-b else ["; null"]]
 ]

```

Using literal (non-quoted) @-arguments will automatically turn on the associated mode refinement. The argument itself will be the appropriate value for the non-@ version of the argument. (WORD! and PATH! will fetch, GROUP! will evaluate, BLOCK! will be unevaluated).

```
 >> demo 1 + 2 10 + 20
 a: 3
 mode-a: ; null
 b: 30
 mode-b: ; null

 >> demo @(1 + 2) 10 + 20
 a: 3
 mode-a: #
 b: 30
 mode-b: ; null

 >> foo: "foo" | demo @[x y z] @foo
 a: [x y z]
 mode-a: #
 b: "foo"
 mode-b: #

 >> foo: [10 @bar] | demo '@[x y z] second foo
 a: @[x y z]
 mode-a: ; null
 b: @bar 
 mode-b: ; null

```

The refinements are available to invoke independently as normal. This means that from a specialization or APPLY standpoint the parameter convention would be as-is.

## Proof-Of-Concept Implementation In Usermode

Here's a sample of how APPEND might splice blocks by default, but suppress with @.

It was designed to operate on top of the Redbol APPEND/ONLY model where splices are default.

```
append: function [
    series
    'nosplice [<skip> the-word! the-path! the-block! the-group!]
    value [<...> any-value!]
    /only
][
    switch type of nosplice [
        null [redbol.append series take value] ; no @... act variadic
        the-block! [redbol.append/only series as block! splicer]
        the-group! [redbol.append/only series do as group! splicer]
        the-word! [redbol.append/only series get splicer]
        the-path! [redbol.append/only series get splicer]
   ]
]

```

## Consequences

This leaves splicing the default:

```
>> append [a b c] [d e]
== [a b c d e]

```

But if you use an @... at the callsite it offers alternate ways of requesting /ONLY:

```
>> append [a b c] @[d e]
== [a b c [d e]]

```

The trickery though is that it _has to be a literal @_... at the callsite. Indirectly that doesn't apply (if it comes from a reference or expression), it will append in the typical fashion, whatever that would be:

```
>> item: @[d e]
== @[d e]

>> append [a b c] item
== [a b c d e] ; or should only plain BLOCK! splice?

```

The callsite permits conventional expressions for the plain case (now an /ONLY behavior), written out as a full evaluation (e.g. the argument is not quoted):

```
>> append [a b c] reverse copy [d e]
== [a b c e d]

```

On the other hand, the /only cases are all going through a quoted argument...but these provide variations besides an @-block:

```
>> append [a b c] @item
== [a b c [d e]]

>> append [a b c] @(reverse copy item)
== [a b c [e d]]

```

And again, these variations are visible at the callsite; they don't accidentally sneak in to run code as /ONLY if your callsite didn't make it look that way just due to some indirect value:

```
>> item: @(reverse copy item)
== @(reverse copy item)

>> append [a b c] item
== [a b c reverse copy item] ; ANY-ARRAY! splice?

```

If you really do want to deliberately append an @... then you can do so with quoting (which you'd have to do for a WORD! or other evaluative type that you didn't mean "do something evaluatory with")

---

<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:** [May 5, 2021, 3:09pm UTC](https://revolt.metaeducation.com/forum/t/shim-code-for-modal-arguments/1185/4 "2021-05-05T15:09:55Z")

</div>

I'll put the former modal tests here in case they ever become interesting later:

```
[
    "Basic operational test"

    (did foo: function [@x /y] [
        reduce .voidify [x y]
    ])

    ([3 ~nulled~] = foo 3)
    ([3 #] = foo @(1 + 2))
    ([@(1 + 2) ~nulled~] = foo '@(1 + 2))

    (did item: 300)

    ([304 ~nulled~] = foo item + 4)
    ([304 #] = foo @(item + 4))
    ([@(item + 4) ~nulled~] = foo '@(item + 4))

    ([300 ~nulled~] = foo item)
    ([300 #] = foo @item)
    ([@item ~nulled~] = foo '@item)

    ([[a b] ~nulled~] = foo [a b])
    ([[a b] #] = foo @[a b])
    ([@[a b] ~nulled~] = foo '@[a b])

    (did obj: make object! [field: 1020])

    ([1020 ~nulled~] = foo obj/field)
    ([1020 #] = foo @obj/field)
    ([@obj/field ~nulled~] = foo '@obj/field)
]

[
    "Basic infix operational test"

    (did bar: infix function [@x /y] [
        reduce .voidify [x y]
    ])

    (3 bar = [3 ~nulled~])
    (@(1 + 2) bar = [3 #])

    (did item: 300)

    ((item + 4) bar = [304 ~nulled~])
    (@(item + 4) bar = [304 #])

    (item bar = [300 ~nulled~])
    (@item bar = [300 #])

    ([a b] bar = [[a b] ~nulled~])
    (@[a b] bar = [[a b] #])

    (did obj: make object! [field: 1020])

    (obj/field bar = [1020 ~nulled~])
    (@obj/field bar = [1020 #])
]

[
    "Demodalizing specialization test"

    (did foo: function [a @x /y] [
        reduce .voidify [a x y]
    ])

    ([a @x /y] = parameters of :foo)

    ([10 20 ~nulled~] = foo 10 20)
    ([10 20 #] = foo 10 @(20))

    (did fooy: :foo/y)

    ([a x] = parameters of :fooy)
    ([10 20 #] = fooy 10 20)
    (
        'bad-parameter = (trap [
            fooy/y 10 20
        ])/id
    )
    (
        'bad-parameter = (trap [
            fooy 10 @(20)
        ])/id
    )
]

; Invisibility sensitivity
;
; Modal parameters use the unevaluated flag to inform callers that an
; argument "dissolved", so they can differentiate @(comment "hi") and @(null)
; The mechanism used is much like how <end> and <opt> are distinguished.
[
    (sensor: func [@arg [<opt> <end> any-value!] /modal] [
        reduce .try [arg modal semiquoted? 'arg]
    ] true)

    ([_ # #[false]] = sensor @(null))
    ([_ # #[true]] = sensor @())
    ([_ # #[true]] = sensor @(comment "hi"))

    ; ([_ # #[true]] = sensor @none) ; !!! maybe this should work?
]

```
