Conjugate a Latin verb

From Rosetta Code
Revision as of 02:39, 24 December 2022 by Alextretyak (talk | contribs) (Added 11l)
(diff) ← Older revision | Latest revision (diff) | Newer revision → (diff)
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
Pointers & references | Addresses

Task
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.


Other tasks related to string operations:
Metrics
Counting
Remove/replace
Anagrams/Derangements/shuffling
Find/Search/Determine
Formatting
Song lyrics/poems/Mad Libs/phrases
Tokenize
Sequences


See also



11l[edit]

Translation of: Python
F conjugate(infinitive)
   I !(infinitive[(len)-3..] == ‘are’)
      print(‘'’infinitive"' non prima coniugatio verbi.\n")
      R

   V stem = infinitive[0 .< (len)-3]
   I stem.empty
      print("\'"infinitive"\' non satis diu conjugatus\n")
      R

   print(‘Praesens indicativi temporis of '’infinitive‘':’)
   L(ending) (‘o’, ‘as’, ‘at’, ‘amus’, ‘atis’, ‘ant’)
      print(‘     ’stem‘’ending)
   print()

L(infinitive) (‘amare’, ‘dare’, ‘qwerty’, ‘are’)
   conjugate(infinitive)
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

ALGOL 68[edit]

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[edit]

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[edit]

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#[edit]

// 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[edit]

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[edit]

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[edit]

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':
    duco     I lead
    ducis    you (singular) lead
    ducit    he, she or it leads
    ducimus  we lead
    ducitis  you (plural) lead
    ducunt   they lead

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[edit]

Translation of: Wren
Works with: jq

Works with gojq, the Go implementation of jq

Part 1[edit]

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[edit]

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[edit]

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[edit]

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':
    duco     I lead
    ducis    you (singular) lead
    ducit    he, she or it leads
    ducimus  we lead
    ducitis  you (plural) lead
    ducunt   they lead

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[edit]

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[edit]

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})
papply({{"amāre","love"},{"dāre","give"},{"vidēre","see"},{"dūcere","lead"},{"audīre","hear"}},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

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):
  dūcō     I lead
  dūcis    you lead
  dūcit    he leads, she leads, it leads
  dūcimus  we lead
  dūcitis  you all lead
  dūcunt   they 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[edit]

/# 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[edit]

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[edit]

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[edit]

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)[edit]

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':
    duco  I lead
    ducis  you (singular) lead
    ducit  he, she or it leads
    ducimus  we lead
    ducitis  you (plural) lead
    ducunt  they lead

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[edit]

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':
    duco     I lead 
    ducis    you (singular) lead 
    ducit    he, she or it leads
    ducimus  we lead 
    ducitis  you (plural) lead 
    ducunt   they lead 

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
Retrieved from "https://rosettacode.org/w/index.php?title=Conjugate_a_Latin_verb&oldid=334692"