# Conjugate a Latin verb

Conjugate a Latin verb is a draft programming task. It is not yet considered ready to be promoted as a complete task, for reasons that should be found in its talk page.

Basic Data Operation
This is a basic data operation. It represents a fundamental action on a basic data type.

You may see other such operations in the Basic Data Operations category, or:

Integer Operations
Arithmetic | Comparison

Boolean Operations
Bitwise | Logical

String Operations
Concatenation | Interpolation | Comparison | Matching

Memory Operations

Create a program that can take a Latin verb and conjugate it, displaying in the following order:
```1st person singular
2nd person singular
3rd person singular
1st person plural
2nd person plural
3rd person plural
```
• Each should be on its own line.
• Have at least one example from each of the 4 conjugations.
• Irregular verbs are not required.
• Translation into English is optional.

## ALGOL 68

```BEGIN # print some Latin verb conjugations #
PROC s length = ( STRING s )INT: ( UPB s + 1 ) - LWB s;      # calculates the length of s #
# prints the cojugations of lv or an error message if we don't know how to conjugate lv #
PROC print conjugations = ( STRING lv )VOID:
IF   []STRING ending    = ( "are", "ēre", "ere", "ire" );
INT length         = s length( lv );
INT conjugation   := 0;
INT ending length := 0;
BOOL long enough  := FALSE;
FOR i FROM LWB ending TO UPB ending WHILE conjugation = 0 DO
ending length := s length( ending[ i ] );
IF ending length < length
THEN
# the word is long enough for at least one ending #
long enough := TRUE;
IF lv[ ( UPB lv + 1 ) - ending length : ] = ending[ i ]
THEN
conjugation := i
FI
FI
OD;
NOT long enough
THEN
print( ( """", lv, """ is not long enough to conjugate", newline ) )
ELIF conjugation = 0
THEN
print( ( "Don't know how to conjugate """, lv, """", newline ) )
ELSE
[,]STRING suffix =  ( (  "o", "as", "at", "amus", "atis",  "ant" )
, ( "eo", "es", "et", "emus", "etis",  "ent" )
, (  "o", "is", "it", "imus", "itis",  "unt" )
, ( "io", "is", "it", "imus", "itis", "iunt" )
);
STRING prefix = lv[ : UPB lv - ending length ];
print( ( "    Conjugations of """, lv, """:", newline ) );
FOR i FROM 2 LWB suffix TO 2 UPB suffix DO
print( ( "        ", prefix, suffix[ conjugation, i ], newline ) )
OD
FI # print confugations # ;
print( ( "Present Indicative conjugation:", newline ) );
print conjugations( "amare"  );
print conjugations( "monēre" );
print conjugations( "tegere" );
print conjugations( "venire" );
print conjugations( "qwerty" );
print conjugations( "are"    )
END```
Output:
```Present Indicative conjugation:
Conjugations of "amare":
amo
amas
amat
amamus
amatis
amant
Conjugations of "monēre":
moneo
mones
monet
monemus
monetis
monent
Conjugations of "tegere":
tego
tegis
tegit
tegimus
tegitis
tegunt
Conjugations of "venire":
venio
venis
venit
venimus
venitis
veniunt
Don't know how to conjugate "qwerty"
"are" is not long enough to conjugate
```

## Arturo

Translation of: Nim
```endings: #[
{are}: ["o" "as" "at" "amus" "atis" "ant"]
{ēre}: ["eo" "es" "et" "emus" "etis" "ent"]
{ere}: ["o" "is" "it" "imus" "itis" "unt"]
{ire}: ["io" "is" "it" "imus" "itis" "iunt"]
]

conjugate: function [v][
suff: join last.n:3 split v
stem: slice v 0 (size v)-4

map endings\[suff] 'x -> stem ++ x
]

loop ["amare" "vidēre" "ducere" "audire"] 'verb [
print repeat "=" 20
print verb
print repeat "=" 20
loop conjugate verb 'row [
print row
]
print ""
]
```
Output:
```====================
amare
====================
amo
amas
amat
amamus
amatis
amant

====================
vidēre
====================
video
vides
videt
videmus
videtis
vident

====================
ducere
====================
duco
ducis
ducit
ducimus
ducitis
ducunt

====================
audire
====================
audio
audis
audit
audimus
auditis
audiunt```

## BQN

Translation of: Nim
```end←⟨"are","ēre","ere","ire"⟩
eCnj←⟨
⟨"o","as","at","amus","atis","ant"⟩
⟨"eo","es","et","emus","etis","ent"⟩
⟨"o","is","it","imus","itis","unt"⟩
⟨"io","is","it","imus","itis","iunt"⟩
⟩
Conj←{(¯3↓𝕩)⊸∾¨eCnj⊑˜⊑end⊐<¯3↑𝕩}

•Show >⋈⟜Conj¨⟨"amare","vidēre","ducere","audire"⟩```
```┌─
╵ "amare"  ⟨ "amo" "amas" "amat" "amamus" "amatis" "amant" ⟩
"vidēre" ⟨ "video" "vides" "videt" "videmus" "videtis" "vident" ⟩
"ducere" ⟨ "duco" "ducis" "ducit" "ducimus" "ducitis" "ducunt" ⟩
"audire" ⟨ "audio" "audis" "audit" "audimus" "auditis" "audiunt" ⟩
┘```

## F#

```// Conjugate a Latin Verb. Nigel Galloway: September 17th., 2021
let myLatin (n:string)=printfn "Rogatus sum iungere verbum %s" n
match n.Length>3,n.[-3..]="are" with
(false,_)|(_,false)->printfn "    facis quod"
|_->["o";"as";"at";"amus";"atis";"ant"]|>List.iter(fun g->printfn "    %s%s" n.[0.. -4] g)
myLatin "amare"
myLatin "creo"
```
Output:
```Rogatus sum iungere verbum amare
amo
amas
amat
amamus
amatis
amant
Rogatus sum iungere verbum creo
facis quod
```

## Factor

Works with: Factor version 0.99 2021-06-02
```USING: formatting io kernel math qw sequences ;

CONSTANT: pronouns {
"I"
"you"
"he, she, it"
"we"
"you all"
"they"
}

CONSTANT: endings qw{ ō ās at āmus ātis ant }

: first-conjugation? ( str -- ? )
qw{ are āre } [ tail? ] with any? ;

: check-first-conjugation ( str -- )
first-conjugation?
[ "Input must end with 'are' or 'āre'." throw ] unless ;

: check-length ( str -- )
length 3 >
[ "Input too short to conjugate." throw ] unless ;

: check-input ( str -- )
[ check-first-conjugation ] [ check-length ] bi ;

: conjugate ( str -- seq )
dup check-input 3 head* endings [ append ] with map ;

: he/she/it ( str -- newstr )
"s" append dup dup "he %s, she %s, it %s" sprintf ;

: english ( str -- seq )
pronouns [ 2 = [ nip he/she/it ] [ " " glue ] if ] with
map-index ;

:: conjugate. ( la en -- )
la en "Present active indicative conjugations of %s (%s):\n"
printf la conjugate en english [ "  %-10s%s\n" printf ] 2each ;

"amāre" "love" conjugate. nl
"dāre" "give" conjugate.
```
Output:
```Present active indicative conjugations of amāre (love):
amō       I love
amās      you love
amat      he loves, she loves, it loves
amāmus    we love
amātis    you all love
amant     they love

Present active indicative conjugations of dāre (give):
dō        I give
dās       you give
dat       he gives, she gives, it gives
dāmus     we give
dātis     you all give
dant      they give
```

## FreeBASIC

Translation of: Wren
```Sub conjugate(infinitive As String)
Dim As String ending(1 To 6) => {"o", "as", "at", "amus", "atis", "ant"}

If Not (Right(infinitive, 3) = "are") Then Print "'"; infinitive; !"' non prima coniugatio verbi.\n" : Exit Sub

Dim As String stem = Left(infinitive, Len(infinitive)-3)
If Len(stem) = 0 Then Print !"\'"; infinitive; !"\' non satis diu conjugatus\n" : Exit Sub

Print Using "Praesens indicativi temporis of '&':"; infinitive

For i As Byte = 1 To 6
Print Spc(5); stem; ending(i)
Next i
Print
End Sub

conjugate("amare")
conjugate("dare")
conjugate("qwerty")
conjugate("are")
Sleep
```
Output:
```Praesens indicativi temporis of 'amare':
amo
amas
amat
amamus
amatis
amant

Praesens indicativi temporis of 'dare':
do
das
dat
damus
datis
dant

'qwerty' non prima coniugatio verbi.

'are' non satis diu conjugatus```

## Go

Translation of: Wren

The 'extended' version.

```package main

import (
"fmt"
"log"
)

var endings = [][]string{
{"o", "as", "at", "amus", "atis", "ant"},
{"eo", "es", "et", "emus", "etis", "ent"},
{"o", "is", "it", "imus", "itis", "unt"},
{"io", "is", "it", "imus", "itis", "iunt"},
}

var infinEndings = []string{"are", "ēre", "ere", "ire"}

var pronouns = []string{"I", "you (singular)", "he, she or it", "we", "you (plural)", "they"}

var englishEndings = []string{"", "", "s", "", "", ""}

func conjugate(infinitive, english string) {
letters := []rune(infinitive)
le := len(letters)
if le < 4 {
log.Fatal("Infinitive is too short for a regular verb.")
}
infinEnding := string(letters[le-3:])
conj := -1
for i, s := range infinEndings {
if s == infinEnding {
conj = i
break
}
}
if conj == -1 {
log.Fatalf("Infinitive ending -%s not recognized.", infinEnding)
}
stem := string(letters[:le-3])
fmt.Printf("Present indicative tense, active voice, of '%s' to '%s':\n", infinitive, english)
for i, ending := range endings[conj] {
fmt.Printf("    %s%-4s  %s %s%s\n", stem, ending, pronouns[i], english, englishEndings[i])
}
fmt.Println()
}

func main() {
pairs := [][2]string{{"amare", "love"}, {"vidēre", "see"}, {"ducere", "lead"}, {"audire", "hear"}}
for _, pair := range pairs {
conjugate(pair[0], pair[1])
}
}
```
Output:
```Present indicative tense, active voice, of 'amare' to 'love':
amo     I love
amas    you (singular) love
amat    he, she or it loves
amamus  we love
amatis  you (plural) love
amant   they love

Present indicative tense, active voice, of 'vidēre' to 'see':
video    I see
vides    you (singular) see
videt    he, she or it sees
videmus  we see
videtis  you (plural) see
vident   they see

Present indicative tense, active voice, of 'ducere' to 'lead':
ducit    he, she or it leads

Present indicative tense, active voice, of 'audire' to 'hear':
audio    I hear
audis    you (singular) hear
audit    he, she or it hears
audimus  we hear
auditis  you (plural) hear
audiunt  they hear
```

## jq

Translation of: Wren
Works with: jq

Works with gojq, the Go implementation of jq

#### Part 1

```def conjugate:
if endswith("are") | not
then "\(.) is not a first conjugation verb." | error
else .[0:-3] as \$stem
| if \$stem|length == 0 then "Stem cannot be empty." | error
else "Present indicative tense of '\(.)':",
( "o", "as", "at", "amus", "atis", "ant"
| "  " + \$stem + .),
""
end
end;

("amare", "dare")
| conjugate```
Output:

As for #Wren.

#### Part 2

```def rpad(\$len): tostring | (\$len - length) as \$l | . + (" " * \$l)[:\$l];

def endings: [
[ "o", "as", "at", "amus", "atis",  "ant"],
["eo", "es", "et", "emus", "etis",  "ent"],
[ "o", "is", "it", "imus", "itis",  "unt"],
["io", "is", "it", "imus", "itis", "iunt"]
];

def infinEndings: ["are", "ēre", "ere", "ire"];

def pronouns: ["I", "you (singular)", "he, she or it", "we", "you (plural)", "they"];

def englishEndings: [ "", "", "s", "", "", "" ];

def conjugate(\$infinitive; \$english):
def letters:  [explode[] | [.] | implode];
(\$infinitive|letters) as \$letters
| if \$letters|length < 4 then "Infinitive is too short for a regular verb." | error
else (\$letters[-3:]|join("")) as \$infinEnding
|  (infinEndings | index(\$infinEnding)) as \$conj
| if \$conj == null then "Infinitive ending -\(\$infinEnding) not recognized." | error
else (\$letters[:-3]|join("")) as \$stem
| "Present indicative tense, active voice, of '\(infinitive)' to '\(\$english)':",
foreach endings[\$conj][] as \$ending (-1; .+1;
"    \(\$stem + \$ending|rpad(8)) \(pronouns[.]) \(\$english)\(englishEndings[.])" )
end
end;

def pairs: [["amare", "love"], ["vidēre", "see"], ["ducere", "lead"], ["audire", "hear"]];

pairs[]
| conjugate(.[0]; .[1])
```
Output:

As for #Wren.

## Julia

```const conjugators = ["ō", "ās", "at", "āmus", "ātis", "ant"]
conjugate(w, gregex = r"[aā]re\$") = (r = replace(w, gregex => ""); [r * s for s in conjugators])

function testregularconjugation(verbvector)
for verb in verbvector
println("\nPresent active indicative conjugation of \$verb:")
for result in conjugate(verb)
println(result)
end
end
end

testregularconjugation(["amāre", "dare"])
```
Output:
```Present active indicative conjugation of amāre:
amō
amās
amat
amāmus
amātis
amant

Present active indicative conjugation of dare:
dō
dās
dat
dāmus
dātis
dant
```

## Nim

Translation of: Go
Works with: Nim version 1.6.0
```import std/[strformat, unicode]

const
Endings = [["o", "as", "at", "amus", "atis", "ant"],
["eo", "es", "et", "emus", "etis", "ent"],
["o", "is", "it", "imus", "itis", "unt"],
["io", "is", "it", "imus", "itis", "iunt"]]
InfinEndings = ["are", "ēre", "ere", "ire"]
Pronouns = ["I", "you (singular)", "he, she or it", "we", "you (plural)", "they"]
EnglishEndings = ["", "", "s", "", "", ""]

proc conjugate(infinitive, english: string) =
let letters = infinitive.toRunes()
if letters.len < 4:
raise newException(ValueError, "infinitive is too short for a regular verb.")
let infinEnding = \$letters[^3..^1]
let conj = InfinEndings.find(infinEnding)
if conj == -1:
raise newException(ValueError, &"infinitive ending -{infinEnding} not recognized.")
let stem = \$letters[0..^4]
echo &"Present indicative tense, active voice, of '{infinitive}' to '{english}':"
for i, ending in Endings[conj]:
echo &"    {stem}{ending:4}  {Pronouns[i]} {english}{EnglishEndings[i]}"
echo()

for (infinitive, english) in {"amare": "love", "vidēre": "see", "ducere": "lead", "audire": "hear"}:
conjugate(infinitive, english)
```
Output:
```Present indicative tense, active voice, of 'amare' to 'love':
amo     I love
amas    you (singular) love
amat    he, she or it loves
amamus  we love
amatis  you (plural) love
amant   they love

Present indicative tense, active voice, of 'vidēre' to 'see':
video    I see
vides    you (singular) see
videt    he, she or it sees
videmus  we see
videtis  you (plural) see
vident   they see

Present indicative tense, active voice, of 'ducere' to 'lead':
ducit    he, she or it leads

Present indicative tense, active voice, of 'audire' to 'hear':
audio    I hear
audis    you (singular) hear
audit    he, she or it hears
audimus  we hear
auditis  you (plural) hear
audiunt  they hear```

## Perl

Translation of: Raku
```use strict;
use warnings;
use feature 'say';
use utf8;
binmode STDOUT, ':utf8';

sub conjugate {
my(\$verb) = shift;
join "\n", map { \$verb . \$_ } qw<ō ās at āmus ātis ant>;
}

for my \$infinitive ('amāre', 'dare') {
say "\nPresent active indicative conjugation of infinitive \$infinitive.";
my(\$verb) = \$infinitive =~ /^ (\w+) [aā] re \$/x;
say \$verb ? conjugate \$verb : "Sorry, don't know how to conjugate \$infinitive"
```
Output:
```Present active indicative conjugation of infinitive amāre.
amō
amās
amat
amāmus
amātis
amant

Present active indicative conjugation of infinitive dare.
dō
dās
dat
dāmus
dātis
dant```

## Phix

TL; DR: Did just one term of Latin, right before posting this realised 'dāre' should probably be 'dare', left as an exercise...

```with javascript_semantics
constant {ending,endings} = columnize({{"āre",split("ō ās at āmus ātis ant")},
{"ēre",split("eō ēs et ēmus ētis ent")},
{"ere",split("ō is it imus itis unt")},
{"īre",split("iō īs it īmus ītis iunt")}}),
pronouns = {"I %s", "you %s", "he %ss, she %ss, it %ss", "we %s", "you all %s", "they %s"}

procedure conjugate(sequence ie)
string {infinitive,english} = ie
sequence utf32 = utf8_to_utf32(infinitive)
assert(length(utf32)>3,"Infinitive is too short for a regular verb.")
string stem = utf32_to_utf8(utf32[1..-4]),
last3 = utf32_to_utf8(utf32[-3..-1])
integer edx = find(last3,ending)
assert(edx!=0,"Infinitive ending -%s not recognized.",{last3})
printf(1,"Present active indicative conjugations of '%s' (%s):\n",ie)
for i=1 to length(endings[edx]) do
string c = sprintf("%s%s",{stem,endings[edx][i]}),
e = substitute(pronouns[i],"%s",english)
printf(1,"  %-7s  %s\n",{c,e})
end for
printf(1,"\n")
end procedure

printf(0,"",{"unicode_align",true})
```
Output:
```Present active indicative conjugations of 'amāre' (love):
amō      I love
amās     you love
amat     he loves, she loves, it loves
amāmus   we love
amātis   you all love
amant    they love

Present active indicative conjugations of 'dāre' (give):
dō       I give
dās      you give
dat      he gives, she gives, it gives
dāmus    we give
dātis    you all give
dant     they give

Present active indicative conjugations of 'vidēre' (see):
videō    I see
vidēs    you see
videt    he sees, she sees, it sees
vidēmus  we see
vidētis  you all see
vident   they see

Present active indicative conjugations of 'dūcere' (lead):

Present active indicative conjugations of 'audīre' (hear):
audiō    I hear
audīs    you hear
audit    he hears, she hears, it hears
audīmus  we hear
audītis  you all hear
audiunt  they hear
```

## Phixmonti

```/# Rosetta Code problem: http://rosettacode.org/wiki/Conjugate_a_Latin_verb
by Galileo, 10/2022 #/

include ..\Utilitys.pmt

( ( "are" "ere" "ire" )
( ( "o" "as" "at" "amus" "atis" "ant" )
( "o" "is" "it" "imus" "itis" "unt" )
( "io" "is" "it" "imus" "itis" "iunt" ) ) )

( "amare" "ducere" "audire" ) len for
get dup print ":" ?
len 2 - snip swap >ps rot swap
getd
len for
get tps swap chain ?
endfor
cps drop swap nl
endfor```
Output:
```
amare:
amo
amas
amat
amamus
amatis
amant
ducere:
duco
ducis
ducit
ducimus
ducitis
ducunt
audire:
audio
audis
audit
audimus
auditis
audiunt
=== Press any key to exit ===

```

## Python

Translation of: Wren
```#!/usr/bin/python

def conjugate(infinitive):
if not infinitive[-3:] == "are":
print("'", infinitive, "' non prima coniugatio verbi.\n", sep='')
return False

stem = infinitive[0:-3]
if len(stem) == 0:
print("\'", infinitive, "\' non satis diu conjugatus\n", sep='')
return False

print("Praesens indicativi temporis of '", infinitive, "':", sep='')
for ending in ("o", "as", "at", "amus", "atis", "ant"):
print("     ", stem, ending, sep='')
print()

if __name__ == '__main__':
for infinitive in ("amare", "dare", "qwerty", "are"):
conjugate(infinitive)
```

## Raku

Translation of: Julia
```for <amāre dare> -> \$infinitive {
say "\nPresent active indicative conjugation of infinitive \$infinitive.";
my \$verb = (\$infinitive ~~ /^ (\w+) ['a'|'ā'] 're' \$/)[0];
say \$verb ?? (conjugate \$verb) !! "Sorry, don't know how to conjugate \$infinitive"
}

sub conjugate (\$verb) { (\$verb X~ <ō ās at āmus ātis ant>).join: "\n" }
```
Output:
```Present active indicative conjugation of infinitive amāre.
amō
amās
amat
amāmus
amātis
amant

Present active indicative conjugation of infinitive dare.
dō
dās
dat
dāmus
dātis
dant```

## REXX

Checks were also made to ensure the Latin verb has only Latin letters (upper and/or lower case).

```/*REXX pgm conjugates (to the terminal) a Latin verb when given a first conjugation verb*/
parse arg verbs
if verbs='' | verbs=","  then verbs= 'amare dare'
suffix= 'o as at amus atis ant'                  /*a list of six Latin verb suffixes.   */
#= words(verbs)                                  /*obtain the # of Latin verbs specified*/

do j=1  for #;                  say        /*process each      "     "       "    */
\$= word(verbs, j);  \$\$= \$;      upper \$\$   /*obtain one of the "     "       "    */
if \datatype(\$, 'M')  then call ser "the following isn't a Latin verb: "      \$
L= length(\$)                               /*obtain the length of a Latin verb.   */
if L<4  then call ser 'length of Latin verb is too short: '     \$
if right(\$\$, 3)\=='ARE'  then call ser "the following isn't a Latin verb: "   \$
stem= left(\$, length(\$) - 3)               /*obtain the stem of the Latin verb.   */
say center(' present indicative tense of "'\$'"', 50, "─")

do k=1  for words(suffix)               /*display each of the verb suffixes.   */
say left('',21) stem || word(suffix, k) /*display a Latin verb stem with auffix*/
end   /*k*/
say
end      /*j*/
exit 0                                           /*stick a fork in it,  we're all done. */
/*──────────────────────────────────────────────────────────────────────────────────────*/
ser:  say;   say '***error*** '  arg(1);   say;   exit 13
```
output   when using the default inputs:
```─────── present indicative tense of "amare"───────
amo
amas
amat
amamus
amatis
amant

─────── present indicative tense of "dare"────────
do
das
dat
damus
datis
dant
```

## V (Vlang)

Translation of: Go

The 'extended' version.

```import log

const
(
endings = [
["o", "as", "at", "amus", "atis", "ant"],
["eo", "es", "et", "emus", "etis", "ent"],
["o", "is", "it", "imus", "itis", "unt"],
["io", "is", "it", "imus", "itis", "iunt"]
]
infin_endings = ["are", "ēre", "ere", "ire"]
pronouns = ["I", "you (singular)", "he, she or it", "we", "you (plural)", "they"]
english_endings = ["", "", "s", "", "", ""]
)

fn main() {
pairs := [["amare", "love"], ["vidēre", "see"], ["ducere", "lead"], ["audire", "hear"]] // add to check errors
for _, pair in pairs {
conjugate(pair[0], pair[1])
}
}

fn conjugate(infinitive string, english string) {
letters := infinitive.runes()
le := letters.len
mut lg := log.Log{}
mut infin_ending, mut stem := '', ''
mut conj := 0
lg.set_level(.error)
lg.set_full_logpath('./info.log')
if le < 4 {
lg.error("Infinitive (\${letters.string()}) is too short for a regular verb.")
exit(1)
}
infin_ending = letters[le - 3..].string()
conj = -1
for i, s in infin_endings {
if s == infin_ending {
conj = i
break
}
}
if conj == -1 {
lg.error("Infinitive ending -\${infin_ending} not recognized.")
exit(1)
}
stem = letters[..le - 3].string()
print("Present indicative tense, active voice, of \${infinitive} to '\${english}':\n")
for i, ending in endings[conj] {
print("	\${stem}\${ending}  \${pronouns[i]} \${english}\${english_endings[i]}\n")
}
println('')
}```
Output:
```Present indicative tense, active voice, of amare to 'love':
amo  I love
amas  you (singular) love
amat  he, she or it loves
amamus  we love
amatis  you (plural) love
amant  they love

Present indicative tense, active voice, of vidēre to 'see':
video  I see
vides  you (singular) see
videt  he, she or it sees
videmus  we see
videtis  you (plural) see
vident  they see

Present indicative tense, active voice, of ducere to 'lead':
ducit  he, she or it leads

Present indicative tense, active voice, of audire to 'hear':
audio  I hear
audis  you (singular) hear
audit  he, she or it hears
audimus  we hear
auditis  you (plural) hear
audiunt  they hear
```

## Wren

```var conjugate = Fn.new { |infinitive|
if (!infinitive.endsWith("are")) Fiber.abort("Not a first conjugation verb.")
var stem = infinitive[0...-3]
if (stem.count == 0) Fiber.abort("Stem cannot be empty.")
System.print("Present indicative tense of '%(infinitive)':")
for (ending in ["o", "as", "at", "amus", "atis", "ant"]) {
System.print("  " + stem + ending)
}
System.print()
}

for (infinitive in ["amare", "dare"]) conjugate.call(infinitive)
```
Output:
```Present indicative tense of 'amare':
amo
amas
amat
amamus
amatis
amant

Present indicative tense of 'dare':
do
das
dat
damus
datis
dant
```

Library: Wren-fmt

The following extended version can deal with regular verbs of all four conjugations. To distinguish 2nd and 3rd conjugations, a bar is placed above the penultimate 'e' in a second conjugation infinitive but accents are otherwise ignored. English meanings have also been added.

```import "/fmt" for Fmt

var endings = [
[ "o", "as", "at", "amus", "atis",  "ant"],
["eo", "es", "et", "emus", "etis",  "ent"],
[ "o", "is", "it", "imus", "itis",  "unt"],
["io", "is", "it", "imus", "itis", "iunt"]
]

var infinEndings = ["are", "ēre", "ere", "ire"]

var pronouns = ["I", "you (singular)", "he, she or it", "we", "you (plural)", "they"]

var englishEndings = [ "", "", "s", "", "", "" ]

var conjugate = Fn.new { |infinitive, english|
var letters = infinitive.toList
if (letters.count < 4) Fiber.abort("Infinitive is too short for a regular verb.")
var infinEnding = letters[-3..-1].join()
var conj = infinEndings.indexOf(infinEnding)
if (conj == -1) Fiber.abort("Infinitive ending -%(infinEnding) not recognized.")
var stem = letters[0..-4].join()
System.print("Present indicative tense, active voice, of '%(infinitive)' to '%(english)':")
var i = 0
for (ending in endings[conj]) {
Fmt.print("    \$s\$-4s  \$s \$s\$s", stem, ending, pronouns[i], english, englishEndings[i])
i = i + 1
}
System.print()
}

var pairs = [["amare", "love"], ["vidēre", "see"], ["ducere", "lead"], ["audire", "hear"]]
for (pair in pairs) conjugate.call(pair[0], pair[1])
```
Output:
```Present indicative tense, active voice, of 'amare' to 'love':
amo     I love
amas    you (singular) love
amat    he, she or it loves
amamus  we love
amatis  you (plural) love
amant   they love

Present indicative tense, active voice, of 'vidēre' to 'see':
video    I see
vides    you (singular) see
videt    he, she or it sees
videmus  we see
videtis  you (plural) see
vident   they see

Present indicative tense, active voice, of 'ducere' to 'lead':