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