eu gosto de codigo limpo e com uma redibilidade direta, no sentido de ter pouca coisa "atrapalhando", por isso tenho preferencia por linguagens baseada em identação no quesito beleza
a primeira paixão nisso foi python

def func(animais,alimento):
    for i in animais:
        if i.come(alimento):
            return true
    return false

gosto dessa parte minima com poucas coisas no meio, isso em outras linguagens ja teria varias chaves, parenteses, e ponto e virgula,

porem com o tempo que fui usando python fui achando alguns incomodos primeiro a parte não ser tipagem estatica (só pra deixar claro q python tem tipagem forte porem n é estatica, sempre vejo confusão com isso), e ficar chamando varias funções seguida acho feio

map(funcao_que_sera aplicada,valida_dados(pega_algo_da_base(escolhe_qual_base,parametros_de_filtro)))

nesse ponto acho feio, dai a alternative é ficar separando isso em variaveis e acho que aumenta muito a carga de inutilidade do codigo

com esses problemas cheguei na linguagem nim, q tambem é baseado em indentação porem com tipagem estatica (o que resolve um dos problemas que tenho com python)

func funcao(animais: array[animal],alimento:comida):bool=
    for i in animais:
        if i.come(alimento):
            true
    false

outra coisa que gosto do nim é o chamado UFCS(Uniform Function Call Syntax), basicamente faz com que os 2 codigos a seguir sejam equivalentes

map(funcao_que_sera_aplicada,valida_dados(pega_algo_da_base(escolhe_qual_base,parametros_de_filtro)))
pode ser usada da como

pega_algo_da_base(escolhe_qual_base,parametros_de_filtro)
.valida_dados()
.map(funcao_que_sera aplicada)

porem ainda tem os tipos explicitos, coisa que gosto no python é que não preciso escrever os tipos(mas é uma linguagem dinamica, sem tipagem estatica o que acho ruim)

dai conheci F# (e a familia de linguagem deriva da linguagem ML):

• é baseado em identação
• é estaticamente tipada
• não é necessario explicitar os tipos
  pra mim pareceu a parfeição de sintaxe

let func arg1 arg2 =
    for i in arg1 do
        if i |> come arg2 then
            true
    else

n tem chaves nem parentes, (claro q isso poderia ser um simples filter mas preciso de exemplos pra descrever)

pode n parecer mas isso é estaticamente tipado, se passar parametro com tipo errado o compilador vai dar erro, é inferencia de tipo que consegue analise o arquivo/modulo inteiro, graças ao algoritmo de Hindley–Milner, é caracterisco das linguagem ML, em varios casos é possivel escrever um projeto inteiro sem escrever os tipos mas sendo estaticamente tipado então tem auxilio do compilador de do LSP(IntelliSense)

aquele encademento pode virar

  pega_algo_da_base(escolhe_qual_base,parametros_de_filtro)
  |> valida_dados()
  |> map(funcao_que_sera aplicada)

elixir teria algo identico, em questão de beleza esses seria os q mais gosto, até por essas questões que as linguagens do tipo lisp são totalmente o contrario dessas coisas(então n curto)
em lisp a função seria algo como

(def func [arg1 arg2]
    (for i in arg1 do
        (if come(i,arg2) 
            true 
            else)))

em lisp é comum ver função terminando em muitos parentes ))))))))))

agora aproveitar o espaço pra fazer uma reclamação de golang, tem uns negocio feio em, pra escrever um simples metodo é

func (*self TipoDoObjeto) nome_do_metodo(primeiro_argumento tipo_do_argumento) (tipo_do_retorno, error)
{ codigo}

comparação com rust,

impl TipoDoObjeto {
    fn nome_do_metodo(&mut self,primeiro_argumento:tipo_do_argumento) -> Result<tipo_do_retorno,error>{}
}

questão de tamanho não muda muito, mas acho muito mais legivel, em go para cada metodo do mesmo objeto teria q repetir (*self TipoDoObjeto) deixando com pouco legivel. rust apesar de ser carregado na sintaxe(diferente da minha preferencia) é muito legivel e agradavel de usar, diria q apesar do rust ser verboso, o codigo diz mais coisa sobre o que esta acontecendo a nivel de LINGUAGEM. gosto de go mas n pelo sintaxe, aqueles encademaneto de função ia ser da forma que acho feia no go(parecido com python), enquanto no rust seria parecido com nim e fsharp