Case Insensitive Naming Conventions - fortran

Question

Completely apart from the discussions about whether programming languages should be case sensitive or not [1] [2], what would be a good naming convention for languages that are case-insensitive?
Specifically I'm working in Fortran, but most commonly available style guides are for languages that are case sensitive, and thus recommend naming conventions like:
Class/Type names are CapitalizedWords
Method/function names are firstWordNotCapitalized
Variables are lower_case_with_underscores
Constants are ALL_CAPS_WITH_UNDERSCORES
But in case insensitive languages, everything is effectively ALL CAPS, so the only way to legibly have multi-word names is ALL_CAPS_WITH_UNDERSCORES. So is my only option for distinguishing between the "kinds" of names to go back to Hungarian Notation?
Class/Type names are APPENDED_WITH_T
Method/function/subroutine names are APPENDED_WITH_{F or S}
Module names are APPENDED_WITH_M
Variable names are NOT_APPENDED (and constants are just variables)
Name collisions are a major problem in Fortran, since even the name of a module will cause a collision with a variable name, or a derived type name. Is this a case where, even though everyone says Hungarian notation is a bad idea, it makes sense in this instance?
Edit:
As a response to a comment, for example, in a case sensitive language (C++ for example) I'd be able to do something like this:
in a file (i.e. module) called Logger.cc:
class Logger {
Logger(some type, of arguments) {...}
log(some argument) {...}
}
in another file somewhere:
#include "Logger.h"
void aFunctionThatCreatesALogger() {
...
Logger logger = new Logger(with, arguments)
...
}
void functionThatLogs(Logger logger) {
...
logger.log(thing)
...
}
And the equivalent Fortran might look like:
in a file (i.e. module name Logger.f90):
module Logger
type Logger
contains
procedure :: log
end type
contains
type(Logger) function Logger(some, arguments) result(logger)
logger%some = some
logger%arguments = arguments
end function Logger
subroutine log(logger, argument)
class(Logger) :: logger
type(some), intent(in) :: argument
...
end subroutine log
end module Logger
in another file somewhere:
module someModule
use Logger, only: Logger, Logger
contains
subroutine routineThatCreatesALogger()
type(Logger) :: logger
...
logger = Logger(with, arguments)
...
end subroutine routineThatCreatesALogger
subroutine routineThatLogs(logger)
type(Logger), intent(in) :: logger
...
call logger%log(thing)
...
end subroutine routineThatLogs
end module someModule
but of course the name collisions between the module name, the type name, the "constructor" function, and my variable name are all a problem, because Fortran can't tell the difference between case and/or context of use.
I fully understand that any suggestions will be highly subjective, but I'd still like to here if anybody has a better/different suggestion than Hungarian notation.

Answer 1

I'm pretty sure that the major reason for the case variations in naming conventions is to give a hint to the human reader as to what that name denotes, not to avoid name clashes.
So unless your compiler really supports only uppercase names, for the most part you can adopt the usual conventions even in case-insensitive languages.
If name clashing really begins to be a problem, using prefixes or suffixes (the latter are most likely preferable) might be ok, but I wouldn't make it a general, compulsory convention, but just a thing to use when it's needed.
And (especially) if you do indeed use them only occasionaly, it's most likely better to use something self-explanatory rather than single letters or strange acronyms.
Your examples aFunctionThatCreatesALogger or functionThatLogs, if they were meant as name proposals, might actually not be the monstrosity that they seem at first glance (if used occasionally), but I'd argue that it's much better to start with the most relevant term (log), and put the eventual specifiers at the end (e.g. loggerCreatingFunction or loggerFunction).
Whether to use a full, expanded term, an abbreviation/acronym or even a single letter should depend mostly on whether most developers use tools with good auto-completion or not.
But you should always be wary to use these specifiers, it's most likely better to avoid things like that as much as possible.
So if you wrote code which declares names that use them, think thrice before committing it.
Note that I don't know Fortran (but I did work a lot with another case-insensitive language).

Answer 2

I'm pretty sure I'm going to stick with my initial idea. Append _t to type names, and in situations where a module contains something with the same name, append _module to module names. Other than that I'll stick with the common convention:
Class/Type names are CapitalizedWords
Method/function names are firstWordNotCapitalized
Variables are lower_case_with_underscores
Constants are ALL_CAPS_WITH_UNDERSCORES
That should avoid the vast majority of naming collisions and (hopefully) produce readable code.
The above Fortran example would then become:
module Logger_module
type Logger_t
contains
procedure :: log
end type
contains
type(Logger_t) function createLogger(some, arguments) result(logger)
logger%some = some
logger%arguments = arguments
end function createLogger
subroutine log(logger, argument)
class(Logger_t) :: logger
type(some_t), intent(in) :: argument
...
end subroutine log
end module Logger
and
module some_module
use Logger_module, only: Logger_t, createLogger
contains
subroutine routineThatCreatesALogger()
type(Logger_t) :: logger
...
logger = createLogger(with, arguments)
...
end subroutine routineThatCreatesALogger
subroutine routineThatLogs(logger)
type(Logger_t), intent(in) :: logger
...
call logger%log(thing)
...
end subroutine routineThatLogs
end module some_module
Of course this ignores the question as to whether you should use a convention that relies on case in a case insensitive language, but that's the kind of question that really invites opinionated and subjective arguments, so I won't ask it.