Applicative Recursion and Nominal Licensing

Pylkkänen’s (2002, 2008) seminal work on applicatives distinguishes two types of applied arguments, high and low, based on their syntactic and semantic properties. High applied arguments, such as benefactives and instruments, are compatible with all types of predicates, including unergative and stative transitive predicates. Examples from the Bantu language Kinyarwanda (spoken in Rwanda) are given in (1), where the verb is marked with the general applicative suffix -ir or the instrumental applicative -ish, subject to vowel harmony.¹

Kinyarwanda also has low applied arguments, such as recipients or goals, which can only be added to dynamic transitive predicates and usually have a transfer-of-possession meaning, as shown in (2).

Kinyarwanda furthermore allows high and low applied arguments to combine, to produce a clause with three (or more) objects. (3a), for instance, features both a benefactive argument and a recipient. Two high applied arguments can also combine in Kinyarwanda; (3b) features both a benefactive and an instrument.

However, there are many languages that have both high and low applicatives but do not allow the two types to combine. For example, Zulu (spoken in South Africa) has been shown to exhibit both types of applicatives (Halpert 2015), yet low and high applied arguments cannot cooccur in the same clause, as the ungrammaticality of (4) shows; adding more applicative morphology on the verb would not improve the example.

It is similarly impossible in Zulu to have two high applied arguments or two low applied arguments in the same clause. In fact, it has been observed that in most languages with applicative morphology, only one applied argument is permitted in any given clause (e.g., Marantz 1993, Rugemalira 1997, McGinnis 1998, Peterson 2007, Nie 2020). Thus, Zulu and many other languages lack the ability to stack, or “recurse,” applied arguments.

The central question of this article is the following: what governs the availability of applicative recursion crosslinguistically? I argue that applicative recursion depends not only on thematic introduction but also on abstract nominal licensing. All nominals must be licensed, and any nominal left unlicensed at the end of a syntactic derivation causes the derivation to crash (e.g., Vergnaud 1977, Chomsky 1981, Sheehan and Van der Wal 2018). I propose that the difference between recursive applicative languages like Kinyarwanda and nonrecursive applicative languages like Zulu lies in whether the applicative heads (Appl) in the respective languages are nominal licensers: Appl heads are licensers in Kinyarwanda but not in Zulu. Applied arguments in Zulu must therefore compete for licensing by a higher head, Voice. Zulu consequently licenses only one applied argument per clause, while Kinyarwanda can license arbitrarily many. Argument introduction and nominal licensing are therefore distinct properties of Appl heads, and nominal licensing is what constrains applicative recursion crosslinguistically.

Bantu languages will play a central role in the discussion of applicatives in this article. On the basis of several raising and agreement diagnostics, Diercks (2012) and others have argued that there is no evidence for abstract Case in Bantu. Sheehan and Van der Wal (2018) have since shown that nominal licensing must operate in at least some Bantu languages, as well as in several unrelated morphologically caseless languages. Applicative recursion provides a novel diagnostic for the presence of abstract nominal licensing, thus supplying additional evidence that Bantu languages make use of a nominal licensing mechanism in the syntax. This licensing is furthermore argued to be driven not by abstract Case but by the need to check ϕ-features.

The rest of the article is organized as follows. I start by showing that crosslinguistic variation in applicative recursion cannot be captured in an approach to argument structure based solely on thematic roles or c-selection (section 2). I argue that some mechanism of abstract nominal licensing is needed to capture applicative recursion in Bantu and other languages (section 3). I sketch an account of licensing based on abstract ϕ-agreement, in which all arguments must have their ϕ-features checked by a nominal licensing head. In languages with licensing Appl heads, applied arguments are always licensed and can therefore recurse. In languages with nonlicensing Appl heads, applied arguments must compete for licensing; this derives the single locus of applicative licensing in nonrecursive languages (section 4). I then discuss the implications of the proposed account for object marking and symmetry in double object constructions (section 5) and for licensing and recursion in Bantu causatives (section 6), before concluding (section 7).

Generative approaches to applicatives take applied arguments to be introduced by a functional head Appl along the extended projection of the verb (e.g., McGinnis 2001, Pylkkänen 2002, 2008, Kim 2011, Jung 2014). Like Voice, which introduces the agent (Kratzer 1996), each Appl head selects for a DP specifier and assigns it a thematic role. Pylkkänen’s (2002, 2008) hierarchy of external-argument-introducing heads is given in (5). High applied arguments are introduced by HighAppl, which merges above the verb V and takes the VP as its complement. Low applied arguments are introduced by LowAppl, which merges below V and has the theme DP as its complement.

Given the structure in (5), we would naturally expect that any language with both high and low applicatives should allow them to cooccur.

However, this prediction is not borne out in every language. While we have seen that some languages like Kinyarwanda do allow multiple applied arguments in a clause, most languages do not. Zulu, for instance, has both high applicatives (6a–b) and low applicatives (6c), assuming that ‘give’ involves a low applicative.² The language nonetheless prohibits high and low applied arguments from cooccurring in the same clause, as shown in (7) (repeated from (4)); again, adding more applicative morphology on the verb does not improve the example.

Similarly, Swahili (lingua franca) and Sesotho (spoken in Lesotho and South Africa) also have high and low applied arguments according to Pylkkänen’s diagnostics, but do not allow them to combine; see the ungrammatical examples in (8) and (9).³ Other Bantu languages with restrictions on the cooccurrence of applied arguments include Bemba (Zambia; Marten and Kula 2014) and Shona (Zimbabwe; Wechsler 2016).⁴

Languages therefore vary in whether they allow recursion of applicatives. In this section, I show that such variation also exists outside of Bantu languages (section 2.1) and outline what kind of syntactic approach is needed to explain this variation (section 2.2).

As reported in Peterson’s (2007) typological survey of applicative constructions, applicative recursion, while uncommon, is nonetheless attested in a number of language families. The majority of Bantu languages seem to allow stacking of multiple applied arguments in the same clause (e.g., Kimenyi 1976, 1995, Satyo 1985, Moshi 1998, Ngoboka 2005, Marlo 2015). Some spectacular examples have been reported from Kinyarwanda, which allows multiple applicative marking on the verb (10).⁵ KiChaga (spoken in Tanzania) also allows multiple applied arguments with a single applicative marker -i (11) on the verb.⁶

Other Bantu languages with applicative recursion include Luganda (Uganda) and isiXhosa (South Africa). The Luganda example in (12) features both a high and a low applicative, while the isiXhosa example in (13) includes at least a benefactive applicative and a reason applicative meaning ‘why’ (i.e., ‘for what’).

Recursive applicative languages are also found outside of Bantu. Some Caucasian languages such as Abaza (spoken in Russia and Turkey) also allow multiple applied arguments; (14) shows that benefactive and locative applicatives can cooccur. The Austronesian language Tukang Besi (Sulawesi, Indonesia) similarly allows two applied arguments in a single clause, such as the benefactive and a comitative in (15).

It can be observed that languages with applicative morphology differ as to whether they have more than one distinct applicative marker. isiXhosa, for instance, marks all applicatives with the morpheme -el (Myler and Mali 2021a), while Abaza has many thematically distinct forms. We will return to this point in section 5.2.2; however, the morphological form of the applicative marker does not seem to interact with applicative recursion, as languages with or without distinct applicative morphemes may or may not allow them to recurse.

Indeed, we have seen that at least a few Bantu languages (Zulu, Swahili, Sesotho, Bemba, and Shona) do not permit more than one applied argument in the same clause. In fact, most languages outside of Bantu seem to disallow applicative recursion. Halkomelem Salish (spoken in British Columbia, Canada), for instance, has distinct morphemes to mark high (16a) and low (16b) applicatives, but these morphemes and their arguments cannot combine (16c) (Samkoe 1994).

Indonesian also has two distinct applicative markers (Sneddon 1996, Cole and Son 2004); -kan can be used to introduce benefactives (17a) and -i introduces recipients (17b). Like Halkomelem but unlike Tukang Besi, Indonesian does not allow applied arguments to cooccur, with either order of applicative morphemes, as shown in (17c).

Many approaches to applicative syntax have focused primarily on argument introduction, that is, where an argument merges in the syntactic hierarchy and what thematic interpretation it receives (e.g., McGinnis 2001, Pylkkänen 2002, 2008, Cuervo 2003, Buell 2005, Kim 2011, Bosse, Bruening, and Yamada 2012, Jung 2014, Jerro 2016). However, the hierarchy alone cannot explain crosslinguistic variation in the availability of applicative recursion. Suppose we adopt a universal hierarchy of functional heads. We would then expect all languages with both HighAppl and LowAppl to allow the two heads to be realized in the same clause and project external arguments. Without further assumptions, it would be a mystery as to why some languages allow this and other languages do not.

Alternatively, we could attempt an analysis based on c-selection, in which nonrecursive applicative languages prohibit one Appl head from selecting another Appl. Note, however, that in Pylkkänen 2002, 2008 and related works, the heads HighAppl and LowAppl are selectionally noncontiguous: HighAppl selects for VP and V selects for LowApplP, as depicted again in (18). There is no local c-selectional relationship between HighAppl and LowAppl; it is therefore unclear how HighAppl could be prevented from selecting a VP that contains a LowApplP.

Further evidence that variation in applicative recursion is not due to restrictions against the cooccurrence of multiple Appl heads (or morphemes) comes from the fact that applicative marking often changes the meaning of the predicate rather than introducing an additional argument (e.g., Peterson 2007, Marten and Mous 2017, Pacchiarotti 2017). Swahili, for instance, has a use of the applicative morpheme that provides an ‘intensive’ meaning indicating repetition or force (Polomé 1967). While Swahili does not allow two applied arguments to cooccur, the language nonetheless allows two instances of the applicative marker on the verb, as long as one of them carries the intensive interpretation. This is shown in (19a–b), which have two instances of the applicative morpheme but optionally permit just one added argument, a locative in this case.

Thus, multiple applicative morphemes may be available in nonrecursive languages, even if multiple applied arguments are not.

In sum, whatever constrains the recursion of applied arguments cannot be due to restrictions on the hierarchy of Appl heads. I assume that Appl heads can combine freely in the syntax, and that it is the distribution of the arguments themselves that is constrained in nonrecursive languages. I propose that the availability of applicative recursion in a language is governed by the general properties of nominal licensing in that language. As a consequence, applicative recursion is constrained not only by argument introduction but also by argument licensing. The status of abstract Case and licensing has long been a topic of contention in the Bantu literature, however; I will therefore address this debate in section 3 before fleshing out my proposal in section 4.

Finally, while the discussion in this article is couched in Minimalism (Chomsky 1995), the observed crosslinguistic variation in applicative recursion would need to be accounted for in any theoretical framework. Any approach to argument structure must be able to capture crosslinguistic differences in the mapping between applicative roles and clausal syntax.⁷

Vergnaud (1977) famously observed that the syntactic distribution of nominals in languages with overt case inflection closely mirrors that of nominals in languages without overt case marking. Nominals in all languages were therefore thought to require some sort of “licensing.” This licensing requirement became known as the Case Filter (Chomsky 1981), which was later operationalized as the checking of a nominal’s abstract Case feature (Chomsky 2000). Importantly, the abstract nominal licensing requirement was found to be distinct from morphological case assignment, as it often produced mismatches with morphological case or had no apparent morphological realization at all (e.g., Zaenen, Maling, and Thráinsson 1985, Marantz 1991, Sigurðsson 1991, 2012, McFadden 2004, Bobaljik 2008).

In this vein, Bantu languages, despite being morphologically caseless, could nonetheless have a nominal licensing requirement. It has been argued, however, that nominals in Bantu have a freer distribution than would be expected for languages with such licensing. Some linguists have therefore proposed that abstract licensing (usually formulated in terms of abstract Case) does not apply in at least some, and perhaps all, Bantu languages (Harford Perez 1985, Markman 2009, Diercks 2012).

Evidence for the claim that Bantu languages lack abstract licensing comes from a number of syntactic diagnostics. I illustrate with just two of them here; see Diercks 2012 and Sheehan and Van der Wal 2018 for additional diagnostics. The first is finiteness, where nominals are generally thought to be licensed in the subject position of finite clauses but not of nonfinite clauses. This is illustrated from English in (20) and (21).

However, several Bantu languages, including Swahili, Digo, Lubukusu (Diercks 2012), and Luganda (Sheehan and Van der Wal 2018), do not appear to exhibit this finiteness restriction. Swahili, for instance, permits both subjects of finite complement CPs (22a) and subjects of nonfinite complement CPs (22b). Nominal licensing of nonfinite subjects therefore does not seem to be required in many Bantu languages.

A second diagnostic relies on the Activity Condition (Chomsky 2000, 2001), in which a nominal that has already been licensed in one position cannot move to another licensing position. English, for example, does not allow a finite subject already licensed in a complement clause to raise to become the subject of the matrix clause (23).

Many Bantu languages, however, appear to flout the Activity Condition and instead exhibit hyperactivity in the form of hyperagreement and hyperraising (e.g., Zeller 2006, Carstens 2011, Carstens and Diercks 2013, Halpert 2015, 2019), where subjects of finite complement CPs can optionally raise into the matrix clause, and both the matrix verb and embedded verb agree with the raised nominal. Examples of hyperraising and hyperagreement are given from Luganda (24) and Zulu (25).

What the results of these diagnostics show is that nominals in (some) Bantu languages do not exhibit the typical restrictions that are normally attributed to abstract licensing. This has led to proposals that Bantu languages have no nominal licensing requirements at all (Harford Perez 1985, Markman 2009, Diercks 2012). Diercks (2012:280), for instance, suggests that since “θ-roles (and argument structure) are independently needed and independently constrain the number and types of arguments that a verb phrase may licitly contain . . . there is no need to invoke a theory of abstract (uninterpretable) Case features to serve the same function.” In other words, only argument introduction matters in Bantu languages, and not argument licensing.

As Van der Wal (2015b) and Sheehan and Van der Wal (2018) have argued, however, some Bantu languages do actually exhibit many classic abstract licensing effects, including finiteness and activity restrictions. These languages include Makhuwa (spoken in Mozambique) and Matengo (Tanzania). Makhuwa, for instance, lacks true raising predicates but nonetheless bans overt subjects of nonfinite clauses. As shown in (26b), nonfinite clausal subjects cannot themselves contain an overt subject.

There is also no evidence of hyperactivity in Makhuwa and Matengo; any apparent instances of multiple agreement, for example, involve not a finite embedded verb but a nonfinite participial form (Van der Wal 2015b).

Even for Zulu and Luganda—which, as we saw above, seem to flout many of the syntactic restrictions normally attributed to abstract licensing—it has been argued that at least some licensing requirements apply (Halpert 2015, Sheehan and Van der Wal 2018). In particular, nominals without the augment (an overt class marker) have a very limited syntactic distribution compared to nominals with the augment. Halpert (2015) argues that the restricted distribution of augmentless nominals in Zulu is evidence that some form of abstract nominal licensing is active in the language.⁸Schneider-Zioga (2019) similarly shows that some augmentless nominals require licensing in Kinande, via partitive case marking (see also Irimia and Schneider-Zioga 2021). Thus, there is a growing body of evidence that nominal licensing indeed plays a role in Bantu syntax.

Applicative recursion lends further support for the presence of nominal licensing in Bantu. If nominals in languages without abstract licensing indeed have a freer distribution than nominals in languages with such licensing, then we would expect there to be a corresponding effect on applicative recursion. In particular, we would predict that languages without licensing will allow applicative recursion. Thus, if Luganda, Zulu, and Swahili indeed lack nominal licensing, then we would expect all three languages to exhibit applicative recursion. However, this prediction is not borne out. As we saw in section 2, while applied arguments can cooccur in Luganda (27), they cannot in Zulu (28) or Swahili (29).

Note that the Zulu example in (28) contains only augmented nominals, meaning that the ungrammaticality of the sentence cannot be due to the influence of a stray augmentless nominal. Thus, there appear to be restrictions on the distribution of even augmented nominals in Zulu.

As I argued in section 2.2, crosslinguistic differences in the availability of applicative recursion cannot plausibly be accounted for by properties of argument introduction alone. The availability of applicative recursion therefore provides an additional diagnostic for the presence of abstract nominal licensing in a language. The fact that applicative recursion is not possible in many previously supposed licensing-free Bantu languages thus adds to the mounting positive evidence for the role of abstract licensing in the language family as a whole.

What exactly is the nature of this abstract licensing? Licensing has traditionally been equated with abstract Case assignment. However, much recent work has shown that abstract Case is insufficient to capture the syntactic distribution of nominals crosslinguistically. Consider, for example, Person-Case Constraint (PCC) effects. Catalan exhibits a canonical (Weak) PCC, whereby the direct object clitic of a clitic cluster can be third person (30a), but the indirect object clitic cannot be third person when the direct object is first or second person (30b), even when the clitics are appropriately case-marked.

Stegovec (2020) has recently shown that the apparent PCC in Slovenian does not implicate case at all, but only person. As exemplified in (31), clitic order in Slovenian is generally flexible; the indirect object clitic can appear before or after the direct object clitic. Note that a third person indirect object clitic can cooccur with a first or second person direct object clitic in (31b), showing that the canonical PCC is not operative in Slovenian.

However, Slovenian does exhibit a particular restriction on clitic clusters: third person clitics crucially cannot precede first or second person clitics, either as direct object or indirect object.

This is illustrated in (32). Stegovec thus argues that Slovenian has a restriction on clitic clusters that is sensitive only to person, not to case.

Several Bantu languages have also been reported to have a version of the PCC (e.g., Riedel 2009, Marten and Kula 2012). Riedel (2009) reports that in Sambaa (spoken in Tanzania), for instance, first and second person direct objects can occur with first and second person indirect objects (33) but not third person indirect objects (34).

Since Bantu languages are morphologically caseless, there is no evidence that the PCC in Bantu is actually tied to abstract Case, much like Slovenian. Furthermore, PCC effects hold not only for person but also for other features such as animacy (e.g., Morolong and Hyman 1977, Riedel 2009) and gender (e.g., Foley and Toosarvandani 2022), suggesting that nominals in many languages require licensing that is independent of abstract Case.

We can thus conclude that abstract Case is neither necessary nor sufficient to account for the syntactic distribution of nominals crosslinguistically (e.g., Marantz 1991, Sigurðsson 1991, 2012, McFadden 2004, T. Levin 2015). Rather, the PCC and related phenomena, such as differential object marking, suggest that nominal licensing is driven by the need to check ϕ-features (e.g., Béjar and Rezac 2003, Danon 2006, Rezac 2011, Preminger 2014, Kalin 2018, 2019). Every language, including those without overt ϕ-agreement, makes person and number distinctions morphosyntactically (Greenberg 1966), whereas many languages have absolutely no overt reflex of Case. I therefore assume that abstract ϕ-feature checking is what drives nominal licensing. Nominals bear ϕ-features, which include person, number, and gender as well as specificity and animacy specifications (Kalin 2019; see also Ormazabal and Romero 2007); some language-specific subset of these features needs to be checked via an Agree relation with a licensing head. For Bantu languages, these features likely include at least gender (e.g., Carstens 2011) and person (e.g., Irimia and Schneider-Zioga 2021, Van der Wal 2022). Effects like the PCC are derived when a nominal with a particular set of ϕ-features (say, first or second person) competes with another nominal for licensing and thus remains unchecked. Any nominal with unchecked ϕ-features at the end of a syntactic derivation causes the derivation to crash.

Note that the current proposal takes ϕ-licensing to be abstract, meaning that it may have no overt realization in a given language. Previous work on Bantu argument structure and agreement has also pointed out the need for an abstract form of licensing that is distinct from overt ϕ-agreement (e.g., Riedel 2009, Halpert 2015, Van der Wal 2015a,b, 2022). Preminger (2019:11), however, has argued that there is “no such thing as morpho-phonologically undetectable [i.e., abstract] ϕ-feature agreement.” His argument is based on the generalization that PCC effects always involve overt ϕ-agreement morphology or clitics. In a model of the grammar where syntax precedes lexical insertion, syntax cannot be sensitive to overtness. Preminger reasons that if the PCC depends on overt agreement, then all agreement must be overt; thus, there is no abstract ϕ-agreement. However, it might not be the case that PCC-type effects in all languages require overt agreement. Sesotho, for instance, exhibits an animacy-based restriction that holds even with full arguments: animate direct objects can either precede or follow animate indirect objects (35) but can only precede inanimate indirect objects (36). Crucially, there is no overt agreement involved here, even though Sesotho allows object marking of both the direct and indirect objects. Thus, Sesotho and languages like it (e.g., Kikuyu, Runyambo; see Bentley 1994 for an overview) may be counterexamples to Preminger’s overtness generalization, which weakens his case against abstract ϕ-agreement.

Assuming, then, that nominal licensing involves abstract ϕ-agreement, I propose that the syntax and realization of nominals can be broken down into the following components: (a) thematic role assignment, (b) abstract ϕ-licensing, (c) morphological case assignment, and (d) morphological ϕ-agreement (see also Sigurðsson 2012). I take thematic role assignment and abstract ϕ-licensing to be language-universal requirements of nominals (although languages may differ as to which ϕ-features need licensing). The realization of overt case and agreement morphology, by contrast, is language-specific. In the next section, I propose an approach to applicative recursion based on abstract ϕ-licensing. Much like the PCC, restrictions on applicative recursion are a result of a competition between nominals for licensing.⁹

Following a number of previous proposals (e.g., Pesetsky and Torrego 2007, Arregi and Nevins 2012, Bhatt and Walkow 2013, Bjorkman and Zeijlstra 2019), I distinguish two components of ϕ-feature agreement between a licensing head (the probe) and a nominal (the goal): (a) checking of valued ϕ-features on the nominal and (b) valuation of unvalued ϕ-features on the licensing head. What I have referred to as “abstract nominal licensing” is the result of ϕ-feature checking. All nominals bear ϕ-features that must be checked by an appropriate probe. Any nominal left with unchecked ϕ-features at the end of a syntactic derivation causes the derivation to crash; this is a universal requirement across languages. ϕ-feature valuation on the probe, by contrast, is associated with overt ϕ-agreement morphology and thus depends on the language involved. This system is schematized in (37) and (38).

I assume the following set of argument-introducing (i.e., thematic role–assigning) heads: Voice, Appl, and V. I assume that T and Voice are nominal licensers in every language; V is also a licenser in languages with double object constructions, in which an applied argument and the theme are equally unmarked. Each licenser probes for a nominal with valued ϕ-features but may not be successful in every derivation; that is, Agree can fail (Preminger 2014). I furthermore assume that nominal licensing occurs downward (e.g., Epstein 1999, Preminger 2013, Polinsky and Preminger 2019) and must be local: licensers probe for the highest nonlicensed argument that they c-command.¹⁰

After a nominal has undergone obligatory ϕ-feature checking with a licensing probe, the nominal can additionally value the ϕ-features of the licenser, giving rise to overt agreement morphology. I assume that T is the locus of subject agreement and Voice the locus of object agreement in Bantu (Van der Wal 2015a, 2022). Overt agreement with the subject is generally obligatory (39a), except in expletive constructions, where the verb takes a default class agreement marker (39b) (e.g., Harford Perez 1985, Halpert 2015).

I assume that the subject of a clause always has its valued ϕ-features checked by T. In constructions with agreeing subjects, the subject also values the ϕ-features on T, which get spelled out as overt subject agreement. In expletive constructions, the ϕ-features on T remain unvalued and are spelled out as the default agreement class.

Similarly, the ϕ-features on Voice may or may not be valued by the nominal that it licenses. Overt object marking depends on the nominal’s salience in the discourse, which is governed by factors such as definiteness, animacy, and topicality/givenness (e.g., Hyman and Duranti 1982, Seidl and Dimitriadis 1997, Ngonyani 1998, Van der Wal 2015a, 2022). In Swahili, for example, definite themes are object-marked on the verb, while indefinite objects are not (40). I suggest that some nominal features (such as gender) need only be licensed via ϕ-feature checking, while other, discourse-salient features (such as person and topicality) also trigger ϕ-feature valuation on the licensing probe, which is spelled out as overt agreement (see also Van der Wal 2022).¹¹

The licensing and overt agreement system sketched here is illustrated in (41) and (42) for a simple transitive clause.¹² A discourse-salient theme may bear, say, a TOP(IC) feature, which triggers ϕ-feature valuation on Voice and overt object marking (e.g., Van der Wal 2015a, 2022). Since V is also a licenser, another possibility is for the theme to undergo ϕ-agreement with V instead of Voice. Interestingly, agreement with V never seems to result in overt object marking in Bantu; this may indicate that the ϕ-features on V never get valued. Overt object marking thus generally reflects agreement with Voice.

As overt agreement provides evidence for licensing, in subsequent trees I will show ϕ-feature valuation whenever it is in principle available, with the acknowledgment that only discourse-salient nominals will trigger the valuation responsible for overt agreement.

The status of T, Voice, and V as nominal licensers is assumed to be uniform across all Bantu languages and in other languages with double object constructions. However, I will argue that languages differ as to whether their Appl heads are licensers, that is, whether Appl is able to check a nominal’s ϕ-features. This difference has direct consequences for the availability of applicative recursion: Appl is a nominal licenser in recursive applicative languages but not in nonrecursive ones (see Wechsler 2016 for similar ideas). Argument introduction and licensing will thus be shown to be distinct properties of functional heads.

The intuition behind a licensing approach to applicative recursion is the following: in nonrecursive applicative languages, such as Zulu and Swahili, only one applied argument can be licensed. Nonrecursive languages must therefore have only one licenser for applied arguments, which I propose is Voice. Appl heads, despite introducing the applied argument thematically, are not themselves nominal licensers (i.e., they do not bear unvalued ϕ-features). Any additional applied arguments that are introduced will thus not be licensed and will lead the derivation to crash.

(43) illustrates a transitive construction with a single high applicative. V introduces the theme and also licenses it by checking its ϕ-features. HighAppl introduces the beneficiary in its specifier but is not a licenser. In order for the derivation to converge, the beneficiary must be licensed by Voice. T licenses the agent.

Since the applied argument is licensed by Voice, and Voice is taken to be the locus of overt object marking, we expect discourse-salient applied arguments to be able to value the ϕ-features of Voice and thus control object marking. This is indeed what we find, as shown in (44) from Swahili.

Since Voice provides the only source of licensing for applied arguments, when more than one applied argument is introduced, they must compete for licensing. A transitive construction with two high applicatives is sketched in (45), where the beneficiary is merged higher than the instrument (see, e.g., Polinsky and Kozinsky 1992, though nothing crucial hinges on this assumption). As before, V introduces and licenses the theme. HighAppl₁ introduces the instrument and HighAppl₂ introduces the beneficiary, but neither head bears the unvalued ϕ₁-features needed to license an argument. Voice is able to license only the more local of the two applied arguments, the beneficiary in this case. Likewise, T can only license the agent. This leaves the lower applied argument unlicensed, causing the derivation to crash.

Thus, the unavailability of applicative recursion in languages such as Zulu and Swahili derives from constraints on nominal licensing. Because Appl is not a nominal licenser in these languages, applied arguments must compete for licensing by Voice, thereby deriving their lack of recursion.

The issue of applicative recursion also has implications for the status of the augment in Bantu languages. Halpert (2015) suggests that the augment provides inherent licensing for each nominal in Zulu; augmented nominals would consequently not require licensing from a functional head along the clausal spine. However, we have seen that Zulu disallows recursion even of augmented applied arguments. If the current proposal regarding recursion and licensing is on the right track, this suggests that even augmented nominals may require licensing from the clausal spine.¹³

Nonrecursive applicative languages therefore show evidence of nominal licensing in general. Thus, applicative recursion—or more precisely, lack thereof—provides a novel diagnostic for the presence of abstract nominal licensing in Bantu languages and beyond.

By contrast, in recursive applicative languages, such as Kinyarwanda and Luganda, Appl heads are nominal licensers. This is illustrated in (46) for the derivation of a transitive predicate with two high applicatives. Because HighAppl heads are licensers in these languages, the lower applied argument, the instrument in this case, can be licensed by the HighAppl₂ head that c-commands it. Since every argument is able to be licensed, the derivation is successful.

I assume that Agree can fail and thus not every licenser in the clause needs to undergo agreement, as shown by HighAppl₁ in (46).¹⁴ What is essential for applicative recursion is that thematic (i.e., argument-introducing) Appl heads can license, so that there are always enough licensers available to license multiple applied arguments.

The proposed analysis assumes that abstract nominal licensing is operative even in recursive applicative languages. Interestingly, because all of the relevant heads are able to license, no “effect” of licensing is observed on the surface in recursive languages; that is, no derivations are ruled out for licensing reasons. The question may therefore arise whether nominal licensing is needed at all in recursive applicative languages. However, we do find independent evidence for a licensing requirement even in recursive Bantu languages, from nominal hierarchy effects like the PCC. We saw in section 3.2 that Sambaa exhibits a version of the PCC, which bars certain combinations of object markers from cooccurring. Haya (spoken in Tanzania) behaves similarly. As shown in (47), Haya is a recursive applicative language.

Some Haya speakers have a version of the PCC in which a first person direct object can cooccur with a second person indirect object but not a third person indirect object (Riedel 2009:141). Thus, while a combination of first and second person object markers results in an ambiguous interpretation (48a), the first and third person object markers together do not (48b).

Nominal hierarchy effects like these indicate that ϕ-features like person and animacy must be licensed even in Bantu languages that allow applicative recursion. Therefore, even recursive applicative languages appear to require abstract nominal licensing.

Summing up the current proposal, variation in the availability of applicative recursion across languages is governed by differences in nominal licensing, which involves the checking of ϕ-features. I proposed that languages differ in whether their thematic Appl heads are nominal licensers. In recursive languages, Appl heads are nominal licensers, which allows multiple applied arguments to have their ϕ-features checked in a single clause. In nonrecursive languages, Appl is not a licenser; applied arguments thus compete for checking by Voice, but only one can ultimately be licensed.

The proposed approach to nominal licensing distinguishes abstract licensing proper (checking of valued ϕ-features on the goal nominal) from overt ϕ-agreement (valuation of unvalued ϕ-features on the licensing probe). Consequently, not every licensing relation will also result in overt agreement. By contrast, every instance of overt agreement should reflect a licensing relation. Thus, we expect more agreement to reflect more licensing.

Bantu languages differ in the number of object markers that are permitted: some allow multiple object markers, others allow only one, and still others permit one regular marker plus an extra one under certain circumstances (1+) (see, e.g., Marten and Kula 2012, Marlo 2015, Van der Wal 2022). If recursive applicative languages indeed have more licensing heads than nonrecursive languages, then we would predict recursive applicative languages to permit more object marking. Table 1 shows the interaction between applicative recursion and object marking in most of the Bantu languages mentioned so far. As the table shows, the prediction based on licensing is borne out: only recursive applicative languages allow multiple object markers. Nonrecursive languages are all 1(+) object-marking languages.

While a larger survey should be conducted to ensure the validity of this correlation throughout the language family, this finding accords remarkably well with Van der Wal’s (2020, 2022) analysis of multiple object marking. Van der Wal proposes that single-object-marking languages only have a ϕ-probe on Voice, whereas multiple-object-marking languages have additional ϕ-probes on Appl. I have similarly argued that nonrecursive applicative languages have Voice but not Appl as a licenser, deriving the fact that nonrecursive languages have only one object marker. Recursive applicative languages do have Appl as an additional licenser; however, not all of them allow multiple object marking. I suggest that in multiple-object-marking languages, Appl can have its ϕ-features valued by a nominal it licenses; in single-object-marking languages, Appl can check ϕ-features of a nominal but does not get its own ϕ-features valued.

Bantu languages also differ in which arguments are permitted to control object marking. In symmetric double object constructions in Bantu and beyond, either the applied argument or the theme can behave as the syntactic object of the clause for a host of properties, including object agreement, passivization, and extraction (e.g., Baker 1988, Bresnan and Moshi 1990, Marantz 1993, Woolford 1993, McGinnis 1998, 2001, Anagnostopoulou 2003, Haddican and Holmberg 2012). This symmetry is exemplified by Zulu object marking in (49).

In asymmetric double object constructions, only the applied argument can behave as the syntactic object of the clause. In Swahili, for instance, the applied argument can control object marking but the theme cannot (50).

If we assume a structure where the applied argument is always merged above the theme, then the asymmetry in languages like Swahili is captured straightforwardly under locality: only the higher of the two arguments can be object-marked. Symmetric constructions, however, appear to violate locality, as agreement and movement operations can target the theme, skipping over the applied argument.

Some recent proposals (Haddican and Holmberg 2012, 2019, Van der Wal 2017, 2022, Holmberg, Sheehan, and Van der Wal 2019) have suggested that double object symmetry arises from variation in the direction of licensing. While in asymmetric constructions Appl can only license the theme, in symmetric constructions Appl can flexibly license either the theme or the applied argument. Whichever argument remains unlicensed by Appl is then licensed by a higher head, which would be Voice in active clauses. The basic proposal is sketched in (51) and (52). In (51), the theme is licensed by Appl; the applied argument is licensed by Voice. If the applied argument is discourse-salient (say, it bears a TOPIC feature; e.g., Van der Wal 2015a, 2022), it can additionally value the ϕ-features on Voice, spelled out overtly as object marking. This derivation would be available for languages with symmetric or asymmetric double object constructions.

An additional derivation is available for languages with symmetric double object constructions. In these languages, Appl can license upward to the applied argument, allowing the theme to be licensed by and undergo ϕ-feature valuation with Voice, as shown in (52). In this derivation, it is the theme that receives object marking.

While the flexible-licensing approach nicely accounts for symmetry between the applied argument and the theme, it crucially assumes that Appl is always a licenser. This is especially important for symmetric object constructions, as it is the flexible licensing behavior of Appl that determines which argument behaves as the syntactic object of the clause. Thus, Appl must necessarily be a licenser in symmetric object constructions. Connecting this to applicative recursion, we have seen that any language with a licensing Appl should in principle allow applicatives to recurse. We would therefore expect all symmetric double object languages to be recursive.

Some languages, such as Kinyarwanda, are indeed both symmetric and recursive (Kimenyi 1976) and may therefore have a flexibly licensing Appl. However, this is not the case for all symmetric languages. Zulu, for instance, was shown to have symmetric double object constructions but nonetheless lacks applicative recursion. Table 2 shows the interaction between applicative recursion and double object symmetry in several of the Bantu languages represented in the article. As the table shows, not all symmetric languages are recursive. In fact, there appears to be no correlation between recursion and symmetry, although again a larger survey should be conducted. Thus, while the flexible-licensing approach to double object symmetry might be appropriate for recursive applicative languages, it does not make the right predictions for nonrecursive languages.

An alternative would be to adopt a movement-based approach to double object symmetry, in which the theme can “leapfrog” into an athematic position above the applied argument within VoiceP (e.g., McGinnis 2001, Doggett 2004). Some recent work on double object licensing has suggested that this position is the specifier of a functional head just under Voice called a raising applicative (RaisAppl) (Georgala, Paul, and Whitman 2008, Georgala 2012, Paul and Whitman 2010, Nie 2019, Myler and Mali 2021a).¹⁵ RaisAppl does not introduce an argument but is able to license. As illustrated in (53), a discourse-salient theme with a TOPIC feature moves to the specifier of RaisAppl, where it becomes local to Voice for licensing and object marking. The applied argument, now no longer local enough to be eligible for agreement from Voice, is licensed instead by RaisAppl.

RaisAppl thus allows the theme to leapfrog past the applied argument and control object marking. Importantly, RaisAppl also licenses the applied argument, which is crucial for nonrecursive languages in which thematic Appls are not licensers.¹⁶

However, there is little evidence that the theme in Zulu, for instance, undergoes short movement to an intermediate position within the VoiceP (e.g., Buell 2005, 2008, Cheng and Downing 2009, Zeller 2012). I suggest that we can nevertheless take advantage of the licensing component of the RaisAppl analysis. I propose that RaisAppl provides an additional source of licensing in symmetric nonrecursive Bantu languages, even if it does not trigger movement. As shown in (54), a discourse-salient theme agrees directly with Voice and gets object-marked, while RaisAppl licenses the applied argument.

By appealing to RaisAppl, we can capture double object symmetry without requiring that all thematic Appl heads be licensers, and thus avoid making the incorrect prediction that all symmetric double object languages should be recursive. The postulation of RaisAppl does have a number of interesting consequences, however, which we will explore in the remainder of this section.

I have proposed in this article that argument introduction and argument licensing are distinct properties of Appl heads. Thematic Appls in some languages are introducers but not licensers. RaisAppl bears the opposite constellation of properties: much like T, it is a licenser but not an introducer. Common to all nonrecursive applicative languages, then, are the three nominal licensing heads T, Voice, and V. In symmetric languages, RaisAppl would merge as an additional licenser whenever there is an argument that would otherwise be left unlicensed. RaisAppl thus has the appearance of a last-resort secondary licenser, which merges only when the derivation would otherwise not converge (e.g., J. Levin and Massam 1985, Bobaljik 1993, Rezac 2011, Kalin 2018). Under the assumption that functional heads merge freely in the syntax, this means that the grammar has the option of merging RaisAppl or not during the derivation. When the theme is discourse-salient and agrees with Voice, as in (54), merging RaisAppl to license the applied argument would result in convergence; an equivalent derivation without RaisAppl would leave the applied argument unlicensed and would thereby crash.

If RaisAppl provides an additional source of licensing in symmetric nonrecursive languages, then we predict constructions with RaisAppl to allow one more applied argument than constructions without it. Some existing data from Sesotho provide preliminary confirmation of this prediction. While Sesotho generally allows only one applied argument per clause, two applied arguments are permitted just in case one of them is discourse-salient, triggering object marking; compare (55a) and (56a) with (55b) and (56b). Agreement between a discourse-salient nominal and Voice and the appearance of RaisAppl thus take place concurrently.¹⁷

As a functional head with unvalued ϕ-features, RaisAppl could also provide another potential locus of object marking. While the two symmetric nonrecursive languages (Zulu and Sesotho) in my sample both have a single object marker, we might expect some symmetric languages to allow an additional object marker when the theme is object-marked. Further investigation of the possibility of additional licensing and object marking via RaisAppl is left for future research.¹⁸

Another topic that warrants further exploration is the realization of applicative morphology in Bantu. In Nie 2019, I show that in Tagalog, both RaisAppl and a thematic Appl can be spelled out overtly under certain conditions. This does not seem to be true for Bantu languages; RaisAppl and thematic Appls are never realized independently. As we saw in section 2.1, however, some recursive languages allow only one overt applicative marker on the verb even when there are multiple applied arguments in the clause. Thus, there seems to be some process of morphological haplology at play that deletes repeated applicative morphemes (see Hyman 2003); this may explain why RaisAppl and thematic Appls never receive independent realizations in the morphology. Another possibility is raised by Myler (2021), who points out that many Bantu languages have a generalized applicative marker that is invariant across several thematic and adverbial interpretations. Myler suggests that the invariant form of this applicative marker can be explained if it is actually the spell-out of a licensing head rather than an argument-introducing head—that is, RaisAppl rather than a thematic Appl. This proposal may lead us to expect that all languages with an invariant applicative marker should have RaisAppl and should therefore be symmetric. However, this is not true for Swahili, for instance. Thus, more work is needed on how the syntax of applicatives maps to their overt morphology.

While this article focuses on the syntax of applicatives, causatives also have the function of introducing additional arguments into the clause. In the literature on argument structure in Bantu, applicative and causative constructions are frequently discussed alongside each other and are generally assumed to have similar syntactic properties. Here, I examine how causatives behave with respect to recursion.

Causatives seem to be able to combine with applicatives in most Bantu languages, even those that disallow applicative stacking. Both the recursive language isiXhosa (57) and the non-recursive Zulu (58), for instance, allow causatives of applicatives, where the applied argument is interpreted as the beneficiary of the lower caused event rather than the higher causing or helping event.¹⁹

All recursive applicative languages seem to allow causatives and applicatives to combine. However, not all nonrecursive languages do. Machobane (1989, 1993) shows that causatives of applicatives are generally prohibited in Sesotho (59).²⁰

I assume an extended argument structure hierarchy as in (60), where a Caus head introduces the causee argument, and Voice introduces the higher agent/causer argument. Given the scopal interpretation of examples (57) and (58), I posit that applied arguments are introduced below the Caus layer. Following the licensing-based approach to argument structure stacking developed in this article, I suggest that Caus is a nominal licenser in isiXhosa and Zulu but not in Sesotho. As shown in (60), Caus provides an additional source of licensing in Zulu so that both the causee and the applied argument can be licensed, by Voice and Caus, respectively. In Sesotho, Caus would not be an additional licenser; the causee and applied argument must therefore compete for licensing by Voice in the same way that two applied arguments do. The lower argument would be left unlicensed and the derivation would therefore crash.

Like thematic Appl heads, then, Caus can vary in its licensing ability across languages, which has consequences for the availability of argument stacking.

If Caus is indeed a nominal licenser in at least some languages, and licensing is what governs the availability of recursion, then we can ask whether some languages will also allow causative recursion. As far as I know, no Bantu language permits causatives to recurse, not even languages like Kinyarwanda that (as we have seen) otherwise have very free licensing.

I argue in Nie 2020, 2022 that the prohibition against causative recursion in Bantu and other languages has a simple independent explanation: the ban on causative recursion is a ban on multiple causees. Assuming that “causee” is a distinct thematic role, its distribution, like that of all thematic roles, must obey the universal principle Thematic Uniqueness, which states that every argument in a clause must bear a different thematic role (e.g., Fillmore 1968, Perlmutter and Postal 1977, Chomsky 1981, Bresnan 1982, Carlson 1984). Thus, causative recursion is impossible in all Bantu languages because it involves thematic role recursion. Just as there are no multiple theme or benefactive arguments in a single clause, there can be no multiple causers or causees.²¹

In the extended argument structure hierarchy sketched in (60), Caus is merged above any Appl heads. This structure was posited on the basis of the relative semantic scope of the causative and applicative morphemes in question. However, some linguists have argued for a structure where Caus is merged below the (high) Appl heads (e.g., Halpert 2015, Banerjee 2019). Such a structure would accord with the causative-applicative order of affixes in the well-known CARP (causative-applicative-reciprocal-passive) morpheme template (Hyman 2003, Good 2005), which affects how causative and applicative combinations are interpreted and realized in some Bantu languages.

However, an implicational hierarchy in double object symmetry uncovered by Van der Wal (2017, 2022) may provide evidence for the Caus > Appl hierarchy proposed above. It is known that double object constructions do not behave uniformly within and across Bantu languages with respect to symmetry (e.g., Baker 1988, Bresnan and Moshi 1990, Alsina and Mchombo 1993, Marantz 1993, Ngonyani 1996). As shown in table 3, Van der Wal demonstrates that languages differ as to whether their causative, high applicative, and/or low applicative constructions exhibit symmetry. While Type 1 languages like Zulu are symmetric for all three types of constructions, Type 2 languages like Sesotho are symmetric for low and high applicatives but not causatives. In the Type 3 language Kiluguru (spoken in Tanzania), only low applicative constructions are symmetric. Type 4 languages like Swahili are asymmetric for all construction types.

From these findings, Van der Wal concludes that double object symmetry in Bantu follows the implicational relation given in (62): if a language is symmetric for one type of construction, it is also symmetric for the construction types to its right.

Notice that the implicational hierarchy in (62) directly corresponds to the structural hierarchy given in (60). I propose that the symmetry cline can receive a structural explanation if we adopt the following assumptions: (a) an argument structure hierarchy as in (60), and (b) that the position of RaisAppl (if present) can vary across languages.

Recall from section 5.2.2 that in symmetric constructions, a RaisAppl head merges to license an argument that would have otherwise been left unlicensed by Voice. It was assumed that RaisAppl merges just below Voice and above all other argument-introducing heads. This captures Type 1 symmetric languages like Zulu in which RaisAppl can facilitate the licensing of any argument, including the causee in (63).

For the other symmetry types, I propose that RaisAppl merges in a lower position. In the Type 2 language Sesotho, RaisAppl merges above HighAppl but below Caus and can thus facilitate the licensing of high and low applied arguments but not causees. This is illustrated in the ungrammatical derivation in (64), where the causee is left unlicensed if Voice agrees with a lower argument. The structure below RaisAppl, however, is symmetric: removing the Caus layer would result in all arguments being licensed.

In the same vein, RaisAppl in Type 3 languages would merge above LowAppl but below HighAppl, licensing a low applied argument but not high applied arguments or causees.

A reversed order of projections, where HighAppl is merged above Caus, would not be able to capture Van der Wal’s implicational hierarchy. Thus, the symmetry cline provides support both for the Caus > Appl structural hierarchy and for the role of RaisAppl in double object symmetry.

In this article, I have argued for the role of abstract nominal licensing in determining the syntactic distribution of nominals in Bantu languages and beyond. I have shown that by recognizing argument introduction and nominal licensing as distinct properties of functional heads, we are able to capture crosslinguistic variation in the syntax of applicatives. Focusing on the availability of applicative recursion, I have argued that some heads introduce arguments but do not license, such as thematic Appl heads in nonrecursive applicative languages; other heads both introduce and license, such as Voice and thematic Appl heads in recursive applicative languages. Finally, there are heads that license but do not introduce, such as T and RaisAppl.

I have also shown that if the proposed licensing-based approach to applicative recursion is on the right track, then it has a number of implications for Bantu languages and languages with double object symmetry. First, it provides a novel diagnostic demonstrating that abstract nominal licensing is operative in Bantu languages (Halpert 2015, Van der Wal 2015b, Sheehan and Van der Wal 2018). Second, it shows that the flexible-licensing approach to double object symmetry (Haddican and Holmberg 2012, 2019, Van der Wal 2017, 2022, Holmberg, Sheehan, and Van der Wal 2019) makes incorrect predictions for nonrecursive applicative languages. I have argued that symmetric but nonrecursive languages are better captured by positing an additional licenser RaisAppl, whose position may vary across languages, deriving Van der Wal’s (2017, 2022) symmetry cline.

The discussion in the article did not distinguish the behavior of high and low applicatives for the purposes of recursion. In principle, however, they could differ. There could very well be a language that has a licensing LowAppl head but a nonlicensing HighAppl head, with the result that low applicatives could recurse and combine with at most one high applicative, but high applicatives could not recurse; the opposite type of language could also exist. I have not yet found clear evidence of a language of either type, but any theory that distinguishes these two types of heads would in principle predict them to be possible.²² If such languages turn out not to be attested, then this could provide support for a more generalized approach to applicatives and argument introducers along the lines of Wood and Marantz’s (2017) i* proposal.

Finally, some recent work has taken advantage of licensing projections such as RaisAppl in accounting for some apparent Mirror Principle–violating instances of causative-applicative affix order induced by the CARP template (Nie 2020, Myler 2021, Myler and Mali 2021a). Myler (2021), for example, points out that the applicative marker can surface “higher” than its semantic scope position but never lower. This can be captured if we posit that RaisAppl provides an additional high locus of applicative marking, and that the applicative marker in question spells out RaisAppl rather than a thematic Appl head. The interaction between nominal licensing and templatic order should thus prove a fruitful avenue for further research.

I am grateful to my language consultants Reagan Otieno Ochieng and Natasha Wijoyo. Thanks also to Jessica Coon, Claire Halpert, Stephanie Harves, Laura Kalin, Richard Kayne, Alec Marantz, Neil Myler, Gary Thoms, and audiences at NYU, Rutgers, Yale, McGill, Leipzig, UMass, and UC Santa Cruz for their feedback at various stages of this work, as well as to two LI reviewers, whose comments were instrumental in refining the ideas presented in this article. This research was supported by funding from the European Research Council (ERC) under the European Union’s Horizon 2020 research and innovation program (LeibnizDream, grant agreement 856421; PIs: Artemis Alexiadou, Maria Teresa Guasti, Uli Sauerland).