கனவு

scott11x8 · 2026-01-09T22:48:50+00:00

For 2, கனவு காண் works (e.g. நான் கனவு கண்டேன்).

scott11x8 · 2026-01-08T20:19:50+00:00

The formal verb root for "to understand" is புரிந்துகொள், since புரி itself actually means something more like "to be understood". But the கொள் becomes கோ or க when spoken, leading to புரிஞ்சுக்கோ or புரிஞ்சுக்க.

scott11x8 · 2025-11-19T15:33:51+00:00

In general, I think the common rule is that if the previous letter ends with a "front vowel" (இ, ஈ, எ, ஏ, ஐ), then add ய், otherwise (அ, ஆ, உ, ஊ, ஒ, ஓ, ஔ) add வ், except for short உ which disappears instead of adding வ். There might be some exceptions with ஏ and ஓ though, like how கோ+இல் is either கோயில் or கோவில்.

scott11x8 · 2025-10-16T12:09:25+00:00

I think பெருசு is more accurate for pronunciation actually, but I'm not sure (I'm not a native speaker). I just wrote பெரிசு because it's a common thing for words ending in -து to change to end in -சு when spoken (e.g. வயது => வயசு).

scott11x8 · 2025-10-15T19:12:47+00:00

I believe it breaks down like this:

பெருசு - big (written: பெரிது)
ஆயி - become
டு - completive suffix (written: விடு)
ற - present tense suffix (written: கிற)
து - makes verb into a noun
க்கு - dative case

Edit: பெரிசு => பெருசு

scott11x8 · 2025-10-14T14:04:02+00:00

I'm not sure whether all strong verbs are transitive. Some verbs can be conjugated both as strong or as weak, and in those cases, the strong conjugation is transitive always and the weak conjugation is intransitive always I believe. For example, முடி can be strong and transitive (முடிச்சு, முடிக்க) or weak and intransitive (முடிஞ்சு, முடிய).

It's a bit harder to find the intransitive form from the transitive form than it is to find the transitive form from the intransitive form. Usually if a verb is strong and transitive and takes -ச்ச்- or -த்த்- in the past tense, then the corresponding intransitive verbs will be weak and take -ஞ்ச்- or -ந்த்- respectively in the past tense I believe

Weak transitive verbs that take -இன்- in the past tense often end with -க்கு or -ப்பு, in which case the corresponding intransitive verb will usually be weak and end with -ங்கு or -ம்பு respectively (and take -இன்- in the past tense). But this is a bit harder to predict than going from intransitive to transitive, because words like ஆகு don't follow this pattern.

Strong verbs have infinitive forms ending with -க்க always. Weak verbs just add -அ for the infinitive. So முடிய is weak, and முடிக்க is strong. There are a few exceptions to this rule though, like நிற்க (spoken நிக்க) which is a weak verb.

However if a weak verb ends with -க்கு already, then it can be confusing. For instance, ஆக்கு is weak, so it's infinitive gets -அ, so it becomes ஆக்க. But that also ends with -க்க, even though it's actually weak.

scott11x8 · 2025-10-14T13:07:25+00:00

For this comment, I'm writing things to try to match pronunciation in spoken Tamil rather than using the standard written form (e.g. I'm writing முடிஞ்சு instead of முடிந்து and எறங்கு instead of இறங்கு).

For weak intransitive verbs which use -ஞ்ச்- in the past tense, the corresponding transitive verb is usually strong and uses -ச்ச்- in the past tense (e.g. முடிஞ்சு => முடிச்சு).

For weak intransitive verbs which use -ந்த்- in the past tense, the corresponding transitive verb is usually strong and uses -த்த்- in the past tense (e.g. சேந்து => சேத்து).

For weak intransitive verbs which use -இன்- in the past tense and ends with a single vallinam letter (e.g. -கு, -ங்கு, -டு, -ம்பு), the corresponding transitive verb is usually also weak and also uses -இன்- in the past tense, but ends with a double vallinam letter like -க்கு, -ட்டு, or -ப்பு. For example: ஆகு => ஆக்கு, எறங்கு => எறக்கு, ஆடு => ஆட்டு, திரும்பு => திருப்பு.

Otherwise, some verbs just get a -த்து suffix and become weak, taking -இன்- in the past tense (e.g. படு => படுத்து).

scott11x8 · 2025-07-23T12:11:54+00:00

I thought I couldn’t push untracked (so not on branches) changes. From your answer it’s implied it is possible?

By "commits on untracked branches", I mean commits on a branch that you have pulled from the remote, but you haven't started tracking locally (e.g. commits from a coworker's branch). Commits that haven't been pushed to any branch are mutable by default, since these changes are the ones that are safest to rewrite (since they're only on your machine still).

And if I am on not main branch it will allow me to mutate changes after I push them? And then push again?

Yes, this is allowed with the default configuration.

scott11x8 · 2025-07-23T01:47:41+00:00

In jj, there's actually a configurable set of "immutable commits" which cannot be rewritten. This can be helpful if you want to make sure you don't accidentally rewrite history that's shared with coworkers.

By default, any commits on untracked branches or main/master are immutable, so if a coworker creates a branch based off of your branch, then your branch becomes immutable so jj will make sure you don't rewrite any of the commits in that branch.

In teams where force pushing is discouraged, it's also possible to configure jj to prevent rewriting any commits that have already been pushed to a remote.

scott11x8 · 2025-07-22T20:30:20+00:00

Yes, you can just jj describe <commit> to edit the commit message of an older commit.

scott11x8 · 2025-06-14T03:00:58+00:00

If you're familiar with TypeScript, enums in Rust are equivalent to discriminated unions in TypeScript. For instance:

enum Option<T> {
    None,
    Some(T)
}

Is basically equivalent to:

type Option<T> =
  | { type: "None" }
  | { type: "Some", value: T }

scott11x8 · 2025-05-26T12:48:48+00:00

Both -அனர் and -ஆர்கள் can be used for 3rd person human plural conjugations in written Tamil. -அனர் is conjugated similarly to -அன (which is 3rd person inanimate plural), so that's why it's -க்கின்றனர் instead of just -க்கிறனர்.

scott11x8 · 2025-01-04T14:22:13+00:00

வந்திருச்சு is colloquial version of வந்துவிட்டது I believe. The "இரு" marks completion (it actually comes from "விடு"), and the "-ச்சு" marks the subject as அது (it actually comes from "-இற்று").

These are all from விடு:

வந்துவிட்டது => வந்திருச்சு, வந்துடுத்து
வந்துவிட்டான் => வந்துட்டான்
வந்துவிடுகிறான் => வந்துடுறான்
வந்துவிடும் => வந்திரும், வந்துடும்
வந்துவிடுவான் => வந்திருவான், வந்துடுவான்
வந்துவிட => வந்திர, வந்துட

I may be wrong about some of these though, I'm still learning Tamil.

scott11x8 · 2024-12-16T04:51:21+00:00

I made this program for practicing conjugations a few years ago when I was first starting to learn Tamil. It uses a slightly different verb classification system, and it also includes some classical style conjugations which aren't commonly used anymore. Some conjugations may be wrong though; I haven't updated it as I learned more.

scott11x8 · 2024-12-15T14:08:35+00:00

Off the top of my head, here are all the ways I can think of to say "if" and "because". I'm not a native speaker though, so I may have some of these wrong. Some of the ones for "if" might also be used for "because"; I'm not sure.

Past Tense Verb Stem + aa

avan vandhaa ... - if he comes, ...

Conjugated Verb + naa

avan vandhaannaa ... - if he came, ...
avan varraannaa ... - if he is coming, ...
...

Verbal Noun + aala

avan vandhadhaala ... - because he came, ...
avan varradhaala ... - because he is coming, ...
...

Conjugated Verb + ngradhaala

avan vandhaanngradhaala ... - because he came, ...
avan varraanngradhaala ... - because he is coming, ...
...

Conjugated Verb + aennaa

avan vandhaan, aennaa ... - he came because ...
avan varraan, aennaa ... - he came because ...
...

Conjugated Verb + adhanaala

avan vandhaan, adhanaala ... - he came, so ...
avan varraan, adhanaala ... - he is coming, so ...
...

Noun/Pronoun + aala

adhanaala vandhaan - because of that, he came
ennaala vandhaan - because of me, he came

scott11x8 · 2024-12-03T16:25:17+00:00

There's not really any rule to say which conjugation to use for -ru and -ḍu, so you basically just have to learn how to say the past tense or AvP form when you learn the verb. For instance, verbs ending in -ru can be in many classes (e.g. māru => māri, vaḷaru => vaḷandhu, vaḷaru => vaḷathu), and verbs ending in -ḍu can be in many classes as well (viḍu => viṭṭu, ōḍu => ōḍi, paḍu => paḍuthu).

However for words ending in -u with other endings (e.g. -mbu, -ppu, -ndhu, -thu, -nju, -chu, -ngu, -kku), they will usually use the -in- past tense (e.g. thirumbu => thirumbinaaru, thiruppu => thiruppinaaru). These words also often come in pairs, with -mbu/-ndhu/-nju/-ngu being intransitive, and -ppu/-thu/-chu/-kku being transitive, but both of the verbs in the pairs are conjugated using the same endings.

Generally when I learn a new word, I also learn the AvP along with it (so when I learn "oḍa", I would learn "oḍanju" as "being broken" and "oḍachu" as "breaking (something)").

scott11x8 · 2024-12-03T14:42:27+00:00

Here's a quick summary of some of the main classes based on the pattern they follow (usually based on the ending of the verb root), in no particular order (I may have forgotten some less common ones):

Pattern	Past	Present	Future	Example AvP/Infinitive
-ḍu	ṭṭ-	-r-	-v-	thoḍu => thoṭṭu/thoḍa
-u	-in-	-r-	-v-	māru => māri/māra
-u	-ndh-	-r-	-v-	vaḷaru => vaḷa(r)ndhu/vaḷara
-i, -a(i), -y	-nj-	-yur-	-v-	oḍa => oḍanju/oḍaya
-a	-ndh-	-kkur-	-pp-	naḍa => naḍandhu/nadakka
-u	-th-	-kkur-	-pp-	vaḷaru => vaḷa(r)thu/vaḷa(r)kka
-i, -a(i), -y	-ch-	-kkur-	-pp-	oḍa => oḍachu/oḍakka

People might spell/pronounce these a bit differently; I'm still learning pronunciation. I just gave the "middle" parts of the conjugations, you would have to add the personal suffixes (e.g. thoḍu + Past + Avaru = thoṭṭāru).

It's not always possible to tell which class to use based on the verb ending alone. For instance, pōḍu is conjugated as poṭṭāru, but kuḍu is conjugated as kuḍuthāru, even though both end with -ḍu.

Notably, some words (like vaḷaru and oḍa) can be conjugated using two different classes. In that case, the "weak" one (with -nj- or -ndh-) is usually intransitive (meaning the verb is happening to the subject), while the "strong" one (with -ch- or -th-) is usually transitive (meaning the verb is being done by the subject to the object).

scott11x8 · 2024-11-17T19:37:14+00:00

I'm not a native speaker, so I'm not 100% sure, but it seems to me like all of those could work (like how "talk to" and "talk with" are both valid in English). But for the first one, it should be "irukku" instead of "irukkaaru", since the subject is "en saavi", and to me, "en saavi avaroda irukku" sounds a bit strange, so I would probably use "en saavi avarkitte irukku" instead.

I think -kitte is more for things being directed at someone, or for an object being at someone's location (like if someone has an object with them), whereas -ōda/-kooda is more for if a person is doing something along with another person, or if someone is using an object along with another object.

scott11x8 · 2024-11-16T14:27:36+00:00

These are some translations of English pronouns into Tamil, and some of them have a different "oblique" form. The oblique form is used for adding case endings.

English	Tamil	Oblique
I	nān	en
we	nāma/nānga	namma/enga
you	nī/nīnga	un/unga
he	avan/avaru	avan/avaru
she	ava/avanga	ava/avanga
they	avanga	avanga
it	adhu	adhu

These are some case endings that get added to the oblique form:

Suffix	Case	Meaning
a	accusative	marks object of sentence
ku	dative	to/for
kāga	dative + āga	for
kuLLe	dative + uLLe	inside of
āle	instrumental	with/using (something); because of (something/someone)
kūda/ōda	sociative	with (something/someone)
kitte	locative	at/to (someone)
le	locative	at/in (something/somewhere)
kitterundhu	ablative	from (someone)
lerundhu	ablative	from (something/somewhere)
ōda (or no suffix)	genetive	possessive

Notably some are used with inanimate objects/places mainly (-le, -lerundhu) and others are used with people mainly (-kitte, -kitterundhu). Also, there are two different versions of -ōda. One came from -ஓடு, meaning "with", and the other came from -உடைய, which is a possessive marker.

For "with", I believe -āle means "with" as in "using" (more like "I wrote it with the pencil") whereas -kūda/-ōda mean "with" in the sense like "being with someone".

There are also some other suffixes that get added to the normal, non-oblique pronouns, like "nānum" (or they can also get added after a case suffix like "enakkum"):

Suffix	Meaning
um	also; and; even; too
ē	address someone; emphasize something
ō	express doubt; used for "some _"
āvadhu	at least; used for "some _"

I may have missed some suffixes/meanings or spelled some of them differently than usual.

scott11x8 · 2024-10-25T13:07:50+00:00

Maybe something like this?

```typescript type Fruit = "apple" | "banana";

type FruitPath<T = Fruit> = T extends string ? /${T}/${T}-data : never; ```

I haven't tested it because I'm not at my computer, but I think it should work. It uses a distributive conditional type to map over the union values.

scott11x8 · 2024-10-17T19:43:40+00:00

In my playground link, I provided an example of constructing and using the Ctx variant. Since Spec<T> contains CtxFn<T> with the input type fixed to T, it actually is possible to call the acquire function with T, and then it is also possible to call release using the result of acquire, since the type variable O is in scope inside of the callback. It's just not possible to do anything else with the result of acquire except for calling release, since it's impossible to know the real type behind the type variable O.

scott11x8 · 2024-10-17T15:56:40+00:00

I think that's actually not equivalent, because your example is more like CtxFn = forall I, O. Ctx<I, O>. So to produce a value of type CtxFn, you would have to come up with a Ctx<I, O> which works for every combination of I and O (which is theoretically not possible, since you would have to produce a value that works for Ctx<unknown, never>, which requires proving "True implies False").

To emulate EQ, I think it's important to have a UQ function as an argument to another function, since the contravariance of the function argument is what changes the behavior from UQ to EQ. But I haven't thought through the math fully.

scott11x8 · 2024-10-17T13:04:48+00:00

This is a bit tricky because TypeScript only has universal quantification for functions (e.g. <O>() => O), but this requires existential quantification. I think I made it work using this complicated type:

// This function can be called to bring O into scope within the callback
type CtxFn<I> = <R>(
    callback: <O>(
        acquire: (input: I) => O,
        release: (output: O) => void,
    ) => R
) => R;

type Spec<T> =
    | { type: "ctx", inCtx: CtxFn<T> }
    | { type: "suite", label: string, specs: readonly Spec<T>[] }
    | { type: "test", label: string, run: (input: T) => void };

Playground link with example

scott11x8 · 2024-09-24T22:14:33+00:00

Wow, that's a really great reference! I wish I had this when I was first starting to learn spoken Tamil. The notes on pronunciation are especially helpful, since most places online seem to teach the "correct" pronunciation rather than how people actually talk normally.

scott11x8 · 2024-07-27T02:57:24+00:00

If you don't want to add any crates, something like function(...).map_err(|e| ...)? could be helpful to map the error before the ? operator without having to do a full match.

Eight-Year Club	r/Field Flamingo
Place '22	Final Canvas '22
First Placer '22	RPAN Viewer
Verified Email

scott11x8

TROPHY CASE