Modifica di Modulo:Fan-conj/man

{{Man modulo}}
Questo [[Aiuto:Moduli|modulo]] costituisce il codice di funzionamento del [[Template:It-conj]] e crea, in base ai parametri inseriti in quest'ultimo, la tabella di coniugazione dei verbi italiani. Si compone di una funzione principale, '''p.itconj''' (richiamata direttamente nel template) e di quattro funzioni accessorie ('''p.over''', '''p.wiki''', '''p.alts''' e '''p.plurale''') che sono utilizzate solo all'interno della funzione principale per abbreviarne il codice (ad es., la funzione p.wiki rende il suo argomento un [[Aiuto:Wikilink|wikilink]]). Le sezioni seguenti illustrano il loro funzionamento, iniziando da quella principale.

Questo modulo è stato importato nel febbraio 2013 a partire dal [[:en:Module:it-conj|corrispondente modulo]] di en.wikt, la cui [https://en.wiktionary.org/w/index.php?title=Module:it-conj&action=history cronologia] riporta i relativi autori (NB: successive modifiche apportate tanto su en. quanto su it. hanno reso i due moduli molto diversi fra loro, per cui i relativi template potrebbero comportarsi in modo molto differente).

==Funzione p.itconj==
È la funzione principale del modulo; interpreta i parametri inseriti nel template (radice, desinenza all'infinito, ausiliare, eventuali forme irregolari) e in base ad essi costruisce la [[:w:Aiuto:Tabelle|tabella]] che ne costituisce l'output. La funzione internamente è suddivisibile in sottosezioni identificate nel modulo dai <code>-- commenti</code>; tali sottosezioni vengono di seguito brevemente descritte separatamente.

La prima sottosezione definisce le variabili passate al modulo dal template:
* <code>stem</code> : la radice del verbo (ad. es. ''parl'' per "parlare", ''corr'' per "correre" e così via); corrisponde al primo parametro del [[Template:It-conj]]
* <code>type</code> : la desinenza (all'infinito) del verbo (''are'', ''ere'', ''arsi'' etc.); corrisponde al secondo parametro del [[Template:It-conj]]
* <code>aus</code> : l'ausiliare (''essere'' o ''avere''); corrisponde al terzo parametro del [[Template:It-conj]]
Successivamente vengono definite le variabili interne al template, che saranno poi codificate successivamente: ad es. <code>inf</code> per la voce verbale all'infinito, <code>pres1s</code> per la prima persona singolare del presente indicativo, <code>prem1s</code> per la prima persona singolare del passato remoto e così via; se si aggiunge una nuova variabile è bene aggiungerla anche a tale lista, altrimenti potrebbe risultare nulla.

Segue poi la costruzione delle voci verbali standard: in base alla desinenza (<code>type</code>) il modulo genera le stringhe per le varie forme flesse unendo radice (<code>stem</code>) e relativa uscita: ad es. se la desinenza è "are" (<code>if type = "are"</code>), <code>pres1s = stem.. "o"</code> (''parlo''); <code>prem1s = stem.. "ai"</code> (''parlai'') e così via. Stesso discorso per i verbi riflessivi (<code>tipe = "arsi"</code> e simili). 

Nella sottosezione identificata da <code>-- Recupera le eventuali forme irregolari o varianti..</code>, le stringhe per le voci verbali così create vengono riunite in stringhe uniche: la funzione p.over sostituisce la forma flessa generata automaticamente con quella eventualmente inserita manualmente nel template, se presente; la funzione p.alts aggiunge alla forma flessa generata automaticamente quella eventualmente inserita manualmente, se presente. Ad es. per il presente indicativo:
* <code>pres1s = p.over(pres1s,args["pres1s"])</code> -> se nel template è inserito il parametro "pres1s=", viene sovrascritto a quello generato automaticamente
* <code>pres1s = p.alts(pres1s, pres1s2)</code> -> se nel template è inserito il parametro "pres1s2=", viene aggiunto accanto a quello generato automaticamente

Nella sottosezione <code>-- Tempi composti</code> vengono generate le forme per i tempi composti (passato prossimo etc.) e i relativi titoli dei cassetti. Prima si genera automaticamente, tramite la funzione p.plurale (vedi sotto), il plurale del participio passato <code>pplur</code> (necessario se l'ausiliare è essere). Successivamente, in base all'ausiliare inserito, si generano le stringhe per le varie voci verbali unendo ausiliare (coniugato) e participio passato: ad es. per il passato prossimo:
* se l'ausiliare è avere (<code>if aus = "avere"</code>), <code>paspros1s = "<nowiki>[[ho]]</nowiki> ".. pp</code> (''ho parlato'') e così via
* se l'ausiliare è essere (<code>if aus = "essere"</code>), <code>paspros1s = "<nowiki>[[sono]]</nowiki> ".. pp</code> (''sono arrossito'') e così via
* se il participio passato non esiste (<code>if pp = ""</code>) le forme composte si annullano <code>paspros1s = ""</code>
* se l'ausiliare è diverso da "essere" o "avere" (<code>else</code>), escono le doppie forme composte <code>paspros1s = "<nowiki>[[ho]]</nowiki> ".. pp, "<nowiki>[[sono]]</nowiki> ".. pp</code> e così via.
Subito dopo si generano i titoli dei cassetti, con la corrispondente descrizione (se <code>if pp = ""</code>, la descrizione è per tutti "manca dei tempi composti").

Infine, nella sottosezione <code>-- Costruisce la tabella di coniugazione</code> il modulo costruisce la tabella (<code>conj</code>) e vi inserisce le forme flesse precedentemente generate. Il modulo restituise tale tabella con output (<code>return conj</code>).

==Funzione p.over==
La funzione p.over (<code>p.over(x,over,xtra)</code>) serve per sovrascrivere l'eventuale voce verbale irregolare (identificata dal suo secondo argomento, <code>over</code>), se definita, a quella generata automaticamente (identificata dal primo argomento <code>x</code>). Ad esempio, all'interno della funzione principale il codice 
*<code>pp = p.over(pp,args["pp"])</code>
cerca l'eventuale parametro "pp=" (participio passato) nel template; se questo è definito (come nel caso del verbo "[[scrivere]]", in cui "pp= scritto") lo rimpiazza alla forma predefinita (che sarebbe, sempre nel caso di "scrivere", ''scrivuto''), se non lo è restituisce invece quest'ultima.

Il terzo parametro <code>xtra</code> va settato su <code>0</code> solo nel caso dei verbi riflessivi, e inserisce la corrispondete particella pronominale ("mi", "ti" etc.), in tutti gli altri casi può essere ignorato. 

==Funzione p.wiki==
La funzione p.wiki (<code>p.wiki(x)</code>) rende il suo argomento, <code>x</code>, un wikilink, con "[[:w:Aiuto:Piped_link#Piped_wikilink|pipe]]" alla sezione italiana. In pratica, nel modulo, scrivere <code>p.wiki(qualcosa)</code> equivale al wikicodice <nowiki>[[qualcosa#Italiano|qualcosa]]</nowiki>.

Inoltre, la funzione controlla, tramite la funzione standard di Scribunto [[:mw:Extension:Scribunto/Lua_reference_manual#mw.title.new|mw.title.new(x).exists]] (si veda anche [[:en:Wiktionary:Scribunto/Converting_templates#Ifexist|qui]]) se la pagina a cui punta tale link esiste o meno (funziona in modo molto simile alla [[:w:Aiuto:Funzioni parser|funzione parser]] ''ifexist'' del codice mediawiki). Se la pagina non esiste, aggiunge al wikilink la [[:Categoria:Verbi italiani con forme da scrivere]], e/o la [[:Categoria:Verbi italiani da scrivere]] se ad essere rosso è il link verso la forma all'infinito.

==Funzione p.alts==
La funzione p.alts (<code>p.alts(x, y)</code>) aggiunge l'eventuale variante alternativa (identificata dal suo secondo argomento, <code>y</code>), se definita, accanto a quella generata automaticamente (identificata dal primo argomento <code>x</code>), separandola con una virgola. Ad esempio, all'interno della funzione principale, il codice
*<code>pp = p.alts(pp, pp2)</code> 
cerca l'eventuale parametro "pp2=" (variante del participio passato) nel template; se questo è definito (come nel caso del verbo "[[vedere]]", in cui "pp2= visto") lo aggiunge al seguito di quella base (che sarebbe, sempre nel caso di "vedere", veduto), se non lo è restituisce invece solo quest'ultima.

==Funzione p.plurale==
La funzione p.plurale (<code>p.plurale(pos, str, r)</code>) sostituisce, al suo argomento <code>str</code>, tanti caratteri quanti sono indicati dall'argomento <code>pos</code> con l'argomento <code>r</code>. In pratica, il codice <code>p.plurale(-1, "cane", i)</code> restituisce "cani". Serve per generare il plurale del participio passato <code>pplur</code> (a sua volta necessario per i tempi composti con ausiliare essere) tramite il codice:
* <code>pplur = p.plurale(-3, pp, "i]]")</code> e simili

<noinclude>[[Categoria:Manuali dei moduli|it-conj]]</noinclude>
<includeonly>[[Categoria:Moduli|it-conj]]</includeonly>